1 /* Subroutines for manipulating rtx's in semantically interesting ways.
2 Copyright (C) 1987, 1991, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
32 #include "hard-reg-set.h"
33 #include "insn-config.h"
36 #if !defined PREFERRED_STACK_BOUNDARY && defined STACK_BOUNDARY
37 #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
40 static rtx break_out_memory_refs PARAMS ((rtx));
41 static void emit_stack_probe PARAMS ((rtx));
44 /* Truncate and perhaps sign-extend C as appropriate for MODE. */
47 trunc_int_for_mode (c, mode)
49 enum machine_mode mode;
51 int width = GET_MODE_BITSIZE (mode);
53 /* Canonicalize BImode to 0 and STORE_FLAG_VALUE. */
55 return c & 1 ? STORE_FLAG_VALUE : 0;
57 /* Sign-extend for the requested mode. */
59 if (width < HOST_BITS_PER_WIDE_INT)
61 HOST_WIDE_INT sign = 1;
71 /* Return an rtx for the sum of X and the integer C.
73 This function should be used via the `plus_constant' macro. */
76 plus_constant_wide (x, c)
78 register HOST_WIDE_INT c;
80 register RTX_CODE code;
82 register enum machine_mode mode;
98 return GEN_INT (INTVAL (x) + c);
102 unsigned HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
103 HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
104 unsigned HOST_WIDE_INT l2 = c;
105 HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
106 unsigned HOST_WIDE_INT lv;
109 add_double (l1, h1, l2, h2, &lv, &hv);
111 return immed_double_const (lv, hv, VOIDmode);
115 /* If this is a reference to the constant pool, try replacing it with
116 a reference to a new constant. If the resulting address isn't
117 valid, don't return it because we have no way to validize it. */
118 if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
119 && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
122 = force_const_mem (GET_MODE (x),
123 plus_constant (get_pool_constant (XEXP (x, 0)),
125 if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
131 /* If adding to something entirely constant, set a flag
132 so that we can add a CONST around the result. */
143 /* The interesting case is adding the integer to a sum.
144 Look for constant term in the sum and combine
145 with C. For an integer constant term, we make a combined
146 integer. For a constant term that is not an explicit integer,
147 we cannot really combine, but group them together anyway.
149 Restart or use a recursive call in case the remaining operand is
150 something that we handle specially, such as a SYMBOL_REF.
152 We may not immediately return from the recursive call here, lest
153 all_constant gets lost. */
155 if (GET_CODE (XEXP (x, 1)) == CONST_INT)
157 c += INTVAL (XEXP (x, 1));
159 if (GET_MODE (x) != VOIDmode)
160 c = trunc_int_for_mode (c, GET_MODE (x));
165 else if (CONSTANT_P (XEXP (x, 1)))
167 x = gen_rtx_PLUS (mode, XEXP (x, 0), plus_constant (XEXP (x, 1), c));
170 else if (find_constant_term_loc (&y))
172 /* We need to be careful since X may be shared and we can't
173 modify it in place. */
174 rtx copy = copy_rtx (x);
175 rtx *const_loc = find_constant_term_loc (©);
177 *const_loc = plus_constant (*const_loc, c);
184 return gen_rtx_LO_SUM (mode, XEXP (x, 0),
185 plus_constant (XEXP (x, 1), c));
193 x = gen_rtx_PLUS (mode, x, GEN_INT (c));
195 if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
197 else if (all_constant)
198 return gen_rtx_CONST (mode, x);
203 /* If X is a sum, return a new sum like X but lacking any constant terms.
204 Add all the removed constant terms into *CONSTPTR.
205 X itself is not altered. The result != X if and only if
206 it is not isomorphic to X. */
209 eliminate_constant_term (x, constptr)
216 if (GET_CODE (x) != PLUS)
219 /* First handle constants appearing at this level explicitly. */
220 if (GET_CODE (XEXP (x, 1)) == CONST_INT
221 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
223 && GET_CODE (tem) == CONST_INT)
226 return eliminate_constant_term (XEXP (x, 0), constptr);
230 x0 = eliminate_constant_term (XEXP (x, 0), &tem);
231 x1 = eliminate_constant_term (XEXP (x, 1), &tem);
232 if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
233 && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
235 && GET_CODE (tem) == CONST_INT)
238 return gen_rtx_PLUS (GET_MODE (x), x0, x1);
244 /* Returns the insn that next references REG after INSN, or 0
245 if REG is clobbered before next referenced or we cannot find
246 an insn that references REG in a straight-line piece of code. */
249 find_next_ref (reg, insn)
255 for (insn = NEXT_INSN (insn); insn; insn = next)
257 next = NEXT_INSN (insn);
258 if (GET_CODE (insn) == NOTE)
260 if (GET_CODE (insn) == CODE_LABEL
261 || GET_CODE (insn) == BARRIER)
263 if (GET_CODE (insn) == INSN
264 || GET_CODE (insn) == JUMP_INSN
265 || GET_CODE (insn) == CALL_INSN)
267 if (reg_set_p (reg, insn))
269 if (reg_mentioned_p (reg, PATTERN (insn)))
271 if (GET_CODE (insn) == JUMP_INSN)
273 if (any_uncondjump_p (insn))
274 next = JUMP_LABEL (insn);
278 if (GET_CODE (insn) == CALL_INSN
279 && REGNO (reg) < FIRST_PSEUDO_REGISTER
280 && call_used_regs[REGNO (reg)])
289 /* Return an rtx for the size in bytes of the value of EXP. */
297 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'd'
298 && DECL_SIZE_UNIT (exp) != 0)
299 size = DECL_SIZE_UNIT (exp);
301 size = size_in_bytes (TREE_TYPE (exp));
303 if (TREE_CODE (size) != INTEGER_CST
304 && contains_placeholder_p (size))
305 size = build (WITH_RECORD_EXPR, sizetype, size, exp);
307 return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype),
308 EXPAND_MEMORY_USE_BAD);
311 /* Return a copy of X in which all memory references
312 and all constants that involve symbol refs
313 have been replaced with new temporary registers.
314 Also emit code to load the memory locations and constants
315 into those registers.
317 If X contains no such constants or memory references,
318 X itself (not a copy) is returned.
320 If a constant is found in the address that is not a legitimate constant
321 in an insn, it is left alone in the hope that it might be valid in the
324 X may contain no arithmetic except addition, subtraction and multiplication.
325 Values returned by expand_expr with 1 for sum_ok fit this constraint. */
328 break_out_memory_refs (x)
331 if (GET_CODE (x) == MEM
332 || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
333 && GET_MODE (x) != VOIDmode))
334 x = force_reg (GET_MODE (x), x);
335 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
336 || GET_CODE (x) == MULT)
338 register rtx op0 = break_out_memory_refs (XEXP (x, 0));
339 register rtx op1 = break_out_memory_refs (XEXP (x, 1));
341 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
342 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
348 #ifdef POINTERS_EXTEND_UNSIGNED
350 /* Given X, a memory address in ptr_mode, convert it to an address
351 in Pmode, or vice versa (TO_MODE says which way). We take advantage of
352 the fact that pointers are not allowed to overflow by commuting arithmetic
353 operations over conversions so that address arithmetic insns can be
357 convert_memory_address (to_mode, x)
358 enum machine_mode to_mode;
361 enum machine_mode from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
364 /* Here we handle some special cases. If none of them apply, fall through
365 to the default case. */
366 switch (GET_CODE (x))
373 if (GET_MODE (SUBREG_REG (x)) == to_mode)
374 return SUBREG_REG (x);
378 temp = gen_rtx_LABEL_REF (to_mode, XEXP (x, 0));
379 LABEL_REF_NONLOCAL_P (temp) = LABEL_REF_NONLOCAL_P (x);
383 temp = gen_rtx_SYMBOL_REF (to_mode, XSTR (x, 0));
384 SYMBOL_REF_FLAG (temp) = SYMBOL_REF_FLAG (x);
385 CONSTANT_POOL_ADDRESS_P (temp) = CONSTANT_POOL_ADDRESS_P (x);
386 STRING_POOL_ADDRESS_P (temp) = STRING_POOL_ADDRESS_P (x);
390 return gen_rtx_CONST (to_mode,
391 convert_memory_address (to_mode, XEXP (x, 0)));
395 /* For addition the second operand is a small constant, we can safely
396 permute the conversion and addition operation. We can always safely
397 permute them if we are making the address narrower. In addition,
398 always permute the operations if this is a constant. */
399 if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
400 || (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT
401 && (INTVAL (XEXP (x, 1)) + 20000 < 40000
402 || CONSTANT_P (XEXP (x, 0)))))
403 return gen_rtx_fmt_ee (GET_CODE (x), to_mode,
404 convert_memory_address (to_mode, XEXP (x, 0)),
405 convert_memory_address (to_mode, XEXP (x, 1)));
412 return convert_modes (to_mode, from_mode,
413 x, POINTERS_EXTEND_UNSIGNED);
417 /* Given a memory address or facsimile X, construct a new address,
418 currently equivalent, that is stable: future stores won't change it.
420 X must be composed of constants, register and memory references
421 combined with addition, subtraction and multiplication:
422 in other words, just what you can get from expand_expr if sum_ok is 1.
424 Works by making copies of all regs and memory locations used
425 by X and combining them the same way X does.
426 You could also stabilize the reference to this address
427 by copying the address to a register with copy_to_reg;
428 but then you wouldn't get indexed addressing in the reference. */
434 if (GET_CODE (x) == REG)
436 if (REGNO (x) != FRAME_POINTER_REGNUM
437 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
438 && REGNO (x) != HARD_FRAME_POINTER_REGNUM
443 else if (GET_CODE (x) == MEM)
445 else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
446 || GET_CODE (x) == MULT)
448 register rtx op0 = copy_all_regs (XEXP (x, 0));
449 register rtx op1 = copy_all_regs (XEXP (x, 1));
450 if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
451 x = gen_rtx_fmt_ee (GET_CODE (x), Pmode, op0, op1);
456 /* Return something equivalent to X but valid as a memory address
457 for something of mode MODE. When X is not itself valid, this
458 works by copying X or subexpressions of it into registers. */
461 memory_address (mode, x)
462 enum machine_mode mode;
465 register rtx oldx = x;
467 if (GET_CODE (x) == ADDRESSOF)
470 #ifdef POINTERS_EXTEND_UNSIGNED
471 if (GET_MODE (x) == ptr_mode)
472 x = convert_memory_address (Pmode, x);
475 /* By passing constant addresses thru registers
476 we get a chance to cse them. */
477 if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
478 x = force_reg (Pmode, x);
480 /* Accept a QUEUED that refers to a REG
481 even though that isn't a valid address.
482 On attempting to put this in an insn we will call protect_from_queue
483 which will turn it into a REG, which is valid. */
484 else if (GET_CODE (x) == QUEUED
485 && GET_CODE (QUEUED_VAR (x)) == REG)
488 /* We get better cse by rejecting indirect addressing at this stage.
489 Let the combiner create indirect addresses where appropriate.
490 For now, generate the code so that the subexpressions useful to share
491 are visible. But not if cse won't be done! */
494 if (! cse_not_expected && GET_CODE (x) != REG)
495 x = break_out_memory_refs (x);
497 /* At this point, any valid address is accepted. */
498 GO_IF_LEGITIMATE_ADDRESS (mode, x, win);
500 /* If it was valid before but breaking out memory refs invalidated it,
501 use it the old way. */
502 if (memory_address_p (mode, oldx))
505 /* Perform machine-dependent transformations on X
506 in certain cases. This is not necessary since the code
507 below can handle all possible cases, but machine-dependent
508 transformations can make better code. */
509 LEGITIMIZE_ADDRESS (x, oldx, mode, win);
511 /* PLUS and MULT can appear in special ways
512 as the result of attempts to make an address usable for indexing.
513 Usually they are dealt with by calling force_operand, below.
514 But a sum containing constant terms is special
515 if removing them makes the sum a valid address:
516 then we generate that address in a register
517 and index off of it. We do this because it often makes
518 shorter code, and because the addresses thus generated
519 in registers often become common subexpressions. */
520 if (GET_CODE (x) == PLUS)
522 rtx constant_term = const0_rtx;
523 rtx y = eliminate_constant_term (x, &constant_term);
524 if (constant_term == const0_rtx
525 || ! memory_address_p (mode, y))
526 x = force_operand (x, NULL_RTX);
529 y = gen_rtx_PLUS (GET_MODE (x), copy_to_reg (y), constant_term);
530 if (! memory_address_p (mode, y))
531 x = force_operand (x, NULL_RTX);
537 else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
538 x = force_operand (x, NULL_RTX);
540 /* If we have a register that's an invalid address,
541 it must be a hard reg of the wrong class. Copy it to a pseudo. */
542 else if (GET_CODE (x) == REG)
545 /* Last resort: copy the value to a register, since
546 the register is a valid address. */
548 x = force_reg (Pmode, x);
555 if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG
556 /* Don't copy an addr via a reg if it is one of our stack slots. */
557 && ! (GET_CODE (x) == PLUS
558 && (XEXP (x, 0) == virtual_stack_vars_rtx
559 || XEXP (x, 0) == virtual_incoming_args_rtx)))
561 if (general_operand (x, Pmode))
562 x = force_reg (Pmode, x);
564 x = force_operand (x, NULL_RTX);
570 /* If we didn't change the address, we are done. Otherwise, mark
571 a reg as a pointer if we have REG or REG + CONST_INT. */
574 else if (GET_CODE (x) == REG)
575 mark_reg_pointer (x, BITS_PER_UNIT);
576 else if (GET_CODE (x) == PLUS
577 && GET_CODE (XEXP (x, 0)) == REG
578 && GET_CODE (XEXP (x, 1)) == CONST_INT)
579 mark_reg_pointer (XEXP (x, 0), BITS_PER_UNIT);
581 /* OLDX may have been the address on a temporary. Update the address
582 to indicate that X is now used. */
583 update_temp_slot_address (oldx, x);
588 /* Like `memory_address' but pretend `flag_force_addr' is 0. */
591 memory_address_noforce (mode, x)
592 enum machine_mode mode;
595 int ambient_force_addr = flag_force_addr;
599 val = memory_address (mode, x);
600 flag_force_addr = ambient_force_addr;
604 /* Convert a mem ref into one with a valid memory address.
605 Pass through anything else unchanged. */
611 if (GET_CODE (ref) != MEM)
613 if (! (flag_force_addr && CONSTANT_ADDRESS_P (XEXP (ref, 0)))
614 && memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
617 /* Don't alter REF itself, since that is probably a stack slot. */
618 return replace_equiv_address (ref, XEXP (ref, 0));
621 /* Given REF, either a MEM or a REG, and T, either the type of X or
622 the expression corresponding to REF, set RTX_UNCHANGING_P if
626 maybe_set_unchanging (ref, t)
630 /* We can set RTX_UNCHANGING_P from TREE_READONLY for decls whose
631 initialization is only executed once, or whose initializer always
632 has the same value. Currently we simplify this to PARM_DECLs in the
633 first case, and decls with TREE_CONSTANT initializers in the second. */
634 if ((TREE_READONLY (t) && DECL_P (t)
635 && (TREE_CODE (t) == PARM_DECL
636 || DECL_INITIAL (t) == NULL_TREE
637 || TREE_CONSTANT (DECL_INITIAL (t))))
638 || TREE_CODE_CLASS (TREE_CODE (t)) == 'c')
639 RTX_UNCHANGING_P (ref) = 1;
642 /* Given REF, a MEM, and T, either the type of X or the expression
643 corresponding to REF, set the memory attributes. OBJECTP is nonzero
644 if we are making a new object of this type. */
647 set_mem_attributes (ref, t, objectp)
654 /* It can happen that type_for_mode was given a mode for which there
655 is no language-level type. In which case it returns NULL, which
660 type = TYPE_P (t) ? t : TREE_TYPE (t);
662 /* Get the alias set from the expression or type (perhaps using a
663 front-end routine) and then copy bits from the type. */
665 /* It is incorrect to set RTX_UNCHANGING_P from TREE_READONLY (type)
666 here, because, in C and C++, the fact that a location is accessed
667 through a const expression does not mean that the value there can
669 MEM_ALIAS_SET (ref) = get_alias_set (t);
670 MEM_VOLATILE_P (ref) = TYPE_VOLATILE (type);
671 MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
673 /* If we are making an object of this type, we know that it is a scalar if
674 the type is not an aggregate. */
675 if (objectp && ! AGGREGATE_TYPE_P (type))
676 MEM_SCALAR_P (ref) = 1;
678 /* If T is a type, this is all we can do. Otherwise, we may be able
679 to deduce some more information about the expression. */
683 maybe_set_unchanging (ref, t);
684 if (TREE_THIS_VOLATILE (t))
685 MEM_VOLATILE_P (ref) = 1;
687 /* Now see if we can say more about whether it's an aggregate or
688 scalar. If we already know it's an aggregate, don't bother. */
689 if (MEM_IN_STRUCT_P (ref))
692 /* Now remove any NOPs: they don't change what the underlying object is.
693 Likewise for SAVE_EXPR. */
694 while (TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR
695 || TREE_CODE (t) == NON_LVALUE_EXPR || TREE_CODE (t) == SAVE_EXPR)
696 t = TREE_OPERAND (t, 0);
698 /* Since we already know the type isn't an aggregate, if this is a decl,
699 it must be a scalar. Or if it is a reference into an aggregate,
700 this is part of an aggregate. Otherwise we don't know. */
702 MEM_SCALAR_P (ref) = 1;
703 else if (TREE_CODE (t) == COMPONENT_REF || TREE_CODE (t) == ARRAY_REF
704 || TREE_CODE (t) == ARRAY_RANGE_REF
705 || TREE_CODE (t) == BIT_FIELD_REF)
706 MEM_IN_STRUCT_P (ref) = 1;
709 /* Return a modified copy of X with its memory address copied
710 into a temporary register to protect it from side effects.
711 If X is not a MEM, it is returned unchanged (and not copied).
712 Perhaps even if it is a MEM, if there is no need to change it. */
719 if (GET_CODE (x) != MEM
720 || ! rtx_unstable_p (XEXP (x, 0)))
724 replace_equiv_address (x, force_reg (Pmode, copy_all_regs (XEXP (x, 0))));
727 /* Copy the value or contents of X to a new temp reg and return that reg. */
733 register rtx temp = gen_reg_rtx (GET_MODE (x));
735 /* If not an operand, must be an address with PLUS and MULT so
736 do the computation. */
737 if (! general_operand (x, VOIDmode))
738 x = force_operand (x, temp);
741 emit_move_insn (temp, x);
746 /* Like copy_to_reg but always give the new register mode Pmode
747 in case X is a constant. */
753 return copy_to_mode_reg (Pmode, x);
756 /* Like copy_to_reg but always give the new register mode MODE
757 in case X is a constant. */
760 copy_to_mode_reg (mode, x)
761 enum machine_mode mode;
764 register rtx temp = gen_reg_rtx (mode);
766 /* If not an operand, must be an address with PLUS and MULT so
767 do the computation. */
768 if (! general_operand (x, VOIDmode))
769 x = force_operand (x, temp);
771 if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode)
774 emit_move_insn (temp, x);
778 /* Load X into a register if it is not already one.
779 Use mode MODE for the register.
780 X should be valid for mode MODE, but it may be a constant which
781 is valid for all integer modes; that's why caller must specify MODE.
783 The caller must not alter the value in the register we return,
784 since we mark it as a "constant" register. */
788 enum machine_mode mode;
791 register rtx temp, insn, set;
793 if (GET_CODE (x) == REG)
796 temp = gen_reg_rtx (mode);
798 if (! general_operand (x, mode))
799 x = force_operand (x, NULL_RTX);
801 insn = emit_move_insn (temp, x);
803 /* Let optimizers know that TEMP's value never changes
804 and that X can be substituted for it. Don't get confused
805 if INSN set something else (such as a SUBREG of TEMP). */
807 && (set = single_set (insn)) != 0
808 && SET_DEST (set) == temp)
810 rtx note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
815 REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, x, REG_NOTES (insn));
820 /* If X is a memory ref, copy its contents to a new temp reg and return
821 that reg. Otherwise, return X. */
829 if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
832 temp = gen_reg_rtx (GET_MODE (x));
833 emit_move_insn (temp, x);
837 /* Copy X to TARGET (if it's nonzero and a reg)
838 or to a new temp reg and return that reg.
839 MODE is the mode to use for X in case it is a constant. */
842 copy_to_suggested_reg (x, target, mode)
844 enum machine_mode mode;
848 if (target && GET_CODE (target) == REG)
851 temp = gen_reg_rtx (mode);
853 emit_move_insn (temp, x);
857 /* Return the mode to use to store a scalar of TYPE and MODE.
858 PUNSIGNEDP points to the signedness of the type and may be adjusted
859 to show what signedness to use on extension operations.
861 FOR_CALL is non-zero if this call is promoting args for a call. */
864 promote_mode (type, mode, punsignedp, for_call)
866 enum machine_mode mode;
868 int for_call ATTRIBUTE_UNUSED;
870 enum tree_code code = TREE_CODE (type);
871 int unsignedp = *punsignedp;
873 #ifdef PROMOTE_FOR_CALL_ONLY
881 case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
882 case CHAR_TYPE: case REAL_TYPE: case OFFSET_TYPE:
883 PROMOTE_MODE (mode, unsignedp, type);
887 #ifdef POINTERS_EXTEND_UNSIGNED
891 unsignedp = POINTERS_EXTEND_UNSIGNED;
899 *punsignedp = unsignedp;
903 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
904 This pops when ADJUST is positive. ADJUST need not be constant. */
907 adjust_stack (adjust)
911 adjust = protect_from_queue (adjust, 0);
913 if (adjust == const0_rtx)
916 /* We expect all variable sized adjustments to be multiple of
917 PREFERRED_STACK_BOUNDARY. */
918 if (GET_CODE (adjust) == CONST_INT)
919 stack_pointer_delta -= INTVAL (adjust);
921 temp = expand_binop (Pmode,
922 #ifdef STACK_GROWS_DOWNWARD
927 stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
930 if (temp != stack_pointer_rtx)
931 emit_move_insn (stack_pointer_rtx, temp);
934 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
935 This pushes when ADJUST is positive. ADJUST need not be constant. */
938 anti_adjust_stack (adjust)
942 adjust = protect_from_queue (adjust, 0);
944 if (adjust == const0_rtx)
947 /* We expect all variable sized adjustments to be multiple of
948 PREFERRED_STACK_BOUNDARY. */
949 if (GET_CODE (adjust) == CONST_INT)
950 stack_pointer_delta += INTVAL (adjust);
952 temp = expand_binop (Pmode,
953 #ifdef STACK_GROWS_DOWNWARD
958 stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
961 if (temp != stack_pointer_rtx)
962 emit_move_insn (stack_pointer_rtx, temp);
965 /* Round the size of a block to be pushed up to the boundary required
966 by this machine. SIZE is the desired size, which need not be constant. */
972 #ifdef PREFERRED_STACK_BOUNDARY
973 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
976 if (GET_CODE (size) == CONST_INT)
978 int new = (INTVAL (size) + align - 1) / align * align;
979 if (INTVAL (size) != new)
980 size = GEN_INT (new);
984 /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
985 but we know it can't. So add ourselves and then do
987 size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1),
988 NULL_RTX, 1, OPTAB_LIB_WIDEN);
989 size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align),
991 size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
993 #endif /* PREFERRED_STACK_BOUNDARY */
997 /* Save the stack pointer for the purpose in SAVE_LEVEL. PSAVE is a pointer
998 to a previously-created save area. If no save area has been allocated,
999 this function will allocate one. If a save area is specified, it
1000 must be of the proper mode.
1002 The insns are emitted after insn AFTER, if nonzero, otherwise the insns
1003 are emitted at the current position. */
1006 emit_stack_save (save_level, psave, after)
1007 enum save_level save_level;
1012 /* The default is that we use a move insn and save in a Pmode object. */
1013 rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
1014 enum machine_mode mode = STACK_SAVEAREA_MODE (save_level);
1016 /* See if this machine has anything special to do for this kind of save. */
1019 #ifdef HAVE_save_stack_block
1021 if (HAVE_save_stack_block)
1022 fcn = gen_save_stack_block;
1025 #ifdef HAVE_save_stack_function
1027 if (HAVE_save_stack_function)
1028 fcn = gen_save_stack_function;
1031 #ifdef HAVE_save_stack_nonlocal
1033 if (HAVE_save_stack_nonlocal)
1034 fcn = gen_save_stack_nonlocal;
1041 /* If there is no save area and we have to allocate one, do so. Otherwise
1042 verify the save area is the proper mode. */
1046 if (mode != VOIDmode)
1048 if (save_level == SAVE_NONLOCAL)
1049 *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
1051 *psave = sa = gen_reg_rtx (mode);
1056 if (mode == VOIDmode || GET_MODE (sa) != mode)
1065 /* We must validize inside the sequence, to ensure that any instructions
1066 created by the validize call also get moved to the right place. */
1068 sa = validize_mem (sa);
1069 emit_insn (fcn (sa, stack_pointer_rtx));
1070 seq = gen_sequence ();
1072 emit_insn_after (seq, after);
1077 sa = validize_mem (sa);
1078 emit_insn (fcn (sa, stack_pointer_rtx));
1082 /* Restore the stack pointer for the purpose in SAVE_LEVEL. SA is the save
1083 area made by emit_stack_save. If it is zero, we have nothing to do.
1085 Put any emitted insns after insn AFTER, if nonzero, otherwise at
1086 current position. */
1089 emit_stack_restore (save_level, sa, after)
1090 enum save_level save_level;
1094 /* The default is that we use a move insn. */
1095 rtx (*fcn) PARAMS ((rtx, rtx)) = gen_move_insn;
1097 /* See if this machine has anything special to do for this kind of save. */
1100 #ifdef HAVE_restore_stack_block
1102 if (HAVE_restore_stack_block)
1103 fcn = gen_restore_stack_block;
1106 #ifdef HAVE_restore_stack_function
1108 if (HAVE_restore_stack_function)
1109 fcn = gen_restore_stack_function;
1112 #ifdef HAVE_restore_stack_nonlocal
1114 if (HAVE_restore_stack_nonlocal)
1115 fcn = gen_restore_stack_nonlocal;
1123 sa = validize_mem (sa);
1130 emit_insn (fcn (stack_pointer_rtx, sa));
1131 seq = gen_sequence ();
1133 emit_insn_after (seq, after);
1136 emit_insn (fcn (stack_pointer_rtx, sa));
1139 #ifdef SETJMP_VIA_SAVE_AREA
1140 /* Optimize RTL generated by allocate_dynamic_stack_space for targets
1141 where SETJMP_VIA_SAVE_AREA is true. The problem is that on these
1142 platforms, the dynamic stack space used can corrupt the original
1143 frame, thus causing a crash if a longjmp unwinds to it. */
1146 optimize_save_area_alloca (insns)
1151 for (insn = insns; insn; insn = NEXT_INSN(insn))
1155 if (GET_CODE (insn) != INSN)
1158 for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
1160 if (REG_NOTE_KIND (note) != REG_SAVE_AREA)
1163 if (!current_function_calls_setjmp)
1165 rtx pat = PATTERN (insn);
1167 /* If we do not see the note in a pattern matching
1168 these precise characteristics, we did something
1169 entirely wrong in allocate_dynamic_stack_space.
1171 Note, one way this could happen is if SETJMP_VIA_SAVE_AREA
1172 was defined on a machine where stacks grow towards higher
1175 Right now only supported port with stack that grow upward
1176 is the HPPA and it does not define SETJMP_VIA_SAVE_AREA. */
1177 if (GET_CODE (pat) != SET
1178 || SET_DEST (pat) != stack_pointer_rtx
1179 || GET_CODE (SET_SRC (pat)) != MINUS
1180 || XEXP (SET_SRC (pat), 0) != stack_pointer_rtx)
1183 /* This will now be transformed into a (set REG REG)
1184 so we can just blow away all the other notes. */
1185 XEXP (SET_SRC (pat), 1) = XEXP (note, 0);
1186 REG_NOTES (insn) = NULL_RTX;
1190 /* setjmp was called, we must remove the REG_SAVE_AREA
1191 note so that later passes do not get confused by its
1193 if (note == REG_NOTES (insn))
1195 REG_NOTES (insn) = XEXP (note, 1);
1201 for (srch = REG_NOTES (insn); srch; srch = XEXP (srch, 1))
1202 if (XEXP (srch, 1) == note)
1205 if (srch == NULL_RTX)
1208 XEXP (srch, 1) = XEXP (note, 1);
1211 /* Once we've seen the note of interest, we need not look at
1212 the rest of them. */
1217 #endif /* SETJMP_VIA_SAVE_AREA */
1219 /* Return an rtx representing the address of an area of memory dynamically
1220 pushed on the stack. This region of memory is always aligned to
1221 a multiple of BIGGEST_ALIGNMENT.
1223 Any required stack pointer alignment is preserved.
1225 SIZE is an rtx representing the size of the area.
1226 TARGET is a place in which the address can be placed.
1228 KNOWN_ALIGN is the alignment (in bits) that we know SIZE has. */
1231 allocate_dynamic_stack_space (size, target, known_align)
1236 #ifdef SETJMP_VIA_SAVE_AREA
1237 rtx setjmpless_size = NULL_RTX;
1240 /* If we're asking for zero bytes, it doesn't matter what we point
1241 to since we can't dereference it. But return a reasonable
1243 if (size == const0_rtx)
1244 return virtual_stack_dynamic_rtx;
1246 /* Otherwise, show we're calling alloca or equivalent. */
1247 current_function_calls_alloca = 1;
1249 /* Ensure the size is in the proper mode. */
1250 if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1251 size = convert_to_mode (Pmode, size, 1);
1253 /* We can't attempt to minimize alignment necessary, because we don't
1254 know the final value of preferred_stack_boundary yet while executing
1256 #ifdef PREFERRED_STACK_BOUNDARY
1257 cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
1260 /* We will need to ensure that the address we return is aligned to
1261 BIGGEST_ALIGNMENT. If STACK_DYNAMIC_OFFSET is defined, we don't
1262 always know its final value at this point in the compilation (it
1263 might depend on the size of the outgoing parameter lists, for
1264 example), so we must align the value to be returned in that case.
1265 (Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if
1266 STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
1267 We must also do an alignment operation on the returned value if
1268 the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
1270 If we have to align, we must leave space in SIZE for the hole
1271 that might result from the alignment operation. */
1273 #if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET) || ! defined (PREFERRED_STACK_BOUNDARY)
1274 #define MUST_ALIGN 1
1276 #define MUST_ALIGN (PREFERRED_STACK_BOUNDARY < BIGGEST_ALIGNMENT)
1281 = force_operand (plus_constant (size,
1282 BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1285 #ifdef SETJMP_VIA_SAVE_AREA
1286 /* If setjmp restores regs from a save area in the stack frame,
1287 avoid clobbering the reg save area. Note that the offset of
1288 virtual_incoming_args_rtx includes the preallocated stack args space.
1289 It would be no problem to clobber that, but it's on the wrong side
1290 of the old save area. */
1293 = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
1294 stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
1296 if (!current_function_calls_setjmp)
1298 int align = PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT;
1300 /* See optimize_save_area_alloca to understand what is being
1303 #if !defined(PREFERRED_STACK_BOUNDARY) || !defined(MUST_ALIGN) || (PREFERRED_STACK_BOUNDARY != BIGGEST_ALIGNMENT)
1304 /* If anyone creates a target with these characteristics, let them
1305 know that our optimization cannot work correctly in such a case. */
1309 if (GET_CODE (size) == CONST_INT)
1311 HOST_WIDE_INT new = INTVAL (size) / align * align;
1313 if (INTVAL (size) != new)
1314 setjmpless_size = GEN_INT (new);
1316 setjmpless_size = size;
1320 /* Since we know overflow is not possible, we avoid using
1321 CEIL_DIV_EXPR and use TRUNC_DIV_EXPR instead. */
1322 setjmpless_size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size,
1323 GEN_INT (align), NULL_RTX, 1);
1324 setjmpless_size = expand_mult (Pmode, setjmpless_size,
1325 GEN_INT (align), NULL_RTX, 1);
1327 /* Our optimization works based upon being able to perform a simple
1328 transformation of this RTL into a (set REG REG) so make sure things
1329 did in fact end up in a REG. */
1330 if (!register_operand (setjmpless_size, Pmode))
1331 setjmpless_size = force_reg (Pmode, setjmpless_size);
1334 size = expand_binop (Pmode, add_optab, size, dynamic_offset,
1335 NULL_RTX, 1, OPTAB_LIB_WIDEN);
1337 #endif /* SETJMP_VIA_SAVE_AREA */
1339 /* Round the size to a multiple of the required stack alignment.
1340 Since the stack if presumed to be rounded before this allocation,
1341 this will maintain the required alignment.
1343 If the stack grows downward, we could save an insn by subtracting
1344 SIZE from the stack pointer and then aligning the stack pointer.
1345 The problem with this is that the stack pointer may be unaligned
1346 between the execution of the subtraction and alignment insns and
1347 some machines do not allow this. Even on those that do, some
1348 signal handlers malfunction if a signal should occur between those
1349 insns. Since this is an extremely rare event, we have no reliable
1350 way of knowing which systems have this problem. So we avoid even
1351 momentarily mis-aligning the stack. */
1353 #ifdef PREFERRED_STACK_BOUNDARY
1354 /* If we added a variable amount to SIZE,
1355 we can no longer assume it is aligned. */
1356 #if !defined (SETJMP_VIA_SAVE_AREA)
1357 if (MUST_ALIGN || known_align % PREFERRED_STACK_BOUNDARY != 0)
1359 size = round_push (size);
1362 do_pending_stack_adjust ();
1364 /* We ought to be called always on the toplevel and stack ought to be aligned
1366 #ifdef PREFERRED_STACK_BOUNDARY
1367 if (stack_pointer_delta % (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT))
1371 /* If needed, check that we have the required amount of stack. Take into
1372 account what has already been checked. */
1373 if (flag_stack_check && ! STACK_CHECK_BUILTIN)
1374 probe_stack_range (STACK_CHECK_MAX_FRAME_SIZE + STACK_CHECK_PROTECT, size);
1376 /* Don't use a TARGET that isn't a pseudo or is the wrong mode. */
1377 if (target == 0 || GET_CODE (target) != REG
1378 || REGNO (target) < FIRST_PSEUDO_REGISTER
1379 || GET_MODE (target) != Pmode)
1380 target = gen_reg_rtx (Pmode);
1382 mark_reg_pointer (target, known_align);
1384 /* Perform the required allocation from the stack. Some systems do
1385 this differently than simply incrementing/decrementing from the
1386 stack pointer, such as acquiring the space by calling malloc(). */
1387 #ifdef HAVE_allocate_stack
1388 if (HAVE_allocate_stack)
1390 enum machine_mode mode = STACK_SIZE_MODE;
1391 insn_operand_predicate_fn pred;
1393 pred = insn_data[(int) CODE_FOR_allocate_stack].operand[0].predicate;
1394 if (pred && ! ((*pred) (target, Pmode)))
1395 #ifdef POINTERS_EXTEND_UNSIGNED
1396 target = convert_memory_address (Pmode, target);
1398 target = copy_to_mode_reg (Pmode, target);
1401 if (mode == VOIDmode)
1404 pred = insn_data[(int) CODE_FOR_allocate_stack].operand[1].predicate;
1405 if (pred && ! ((*pred) (size, mode)))
1406 size = copy_to_mode_reg (mode, size);
1408 emit_insn (gen_allocate_stack (target, size));
1413 #ifndef STACK_GROWS_DOWNWARD
1414 emit_move_insn (target, virtual_stack_dynamic_rtx);
1417 /* Check stack bounds if necessary. */
1418 if (current_function_limit_stack)
1421 rtx space_available = gen_label_rtx ();
1422 #ifdef STACK_GROWS_DOWNWARD
1423 available = expand_binop (Pmode, sub_optab,
1424 stack_pointer_rtx, stack_limit_rtx,
1425 NULL_RTX, 1, OPTAB_WIDEN);
1427 available = expand_binop (Pmode, sub_optab,
1428 stack_limit_rtx, stack_pointer_rtx,
1429 NULL_RTX, 1, OPTAB_WIDEN);
1431 emit_cmp_and_jump_insns (available, size, GEU, NULL_RTX, Pmode, 1,
1432 0, space_available);
1435 emit_insn (gen_trap ());
1438 error ("stack limits not supported on this target");
1440 emit_label (space_available);
1443 anti_adjust_stack (size);
1444 #ifdef SETJMP_VIA_SAVE_AREA
1445 if (setjmpless_size != NULL_RTX)
1447 rtx note_target = get_last_insn ();
1449 REG_NOTES (note_target)
1450 = gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size,
1451 REG_NOTES (note_target));
1453 #endif /* SETJMP_VIA_SAVE_AREA */
1455 #ifdef STACK_GROWS_DOWNWARD
1456 emit_move_insn (target, virtual_stack_dynamic_rtx);
1462 /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
1463 but we know it can't. So add ourselves and then do
1465 target = expand_binop (Pmode, add_optab, target,
1466 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1467 NULL_RTX, 1, OPTAB_LIB_WIDEN);
1468 target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
1469 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1471 target = expand_mult (Pmode, target,
1472 GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1476 /* Some systems require a particular insn to refer to the stack
1477 to make the pages exist. */
1480 emit_insn (gen_probe ());
1483 /* Record the new stack level for nonlocal gotos. */
1484 if (nonlocal_goto_handler_slots != 0)
1485 emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
1490 /* A front end may want to override GCC's stack checking by providing a
1491 run-time routine to call to check the stack, so provide a mechanism for
1492 calling that routine. */
1494 static rtx stack_check_libfunc;
1497 set_stack_check_libfunc (libfunc)
1500 stack_check_libfunc = libfunc;
1503 /* Emit one stack probe at ADDRESS, an address within the stack. */
1506 emit_stack_probe (address)
1509 rtx memref = gen_rtx_MEM (word_mode, address);
1511 MEM_VOLATILE_P (memref) = 1;
1513 if (STACK_CHECK_PROBE_LOAD)
1514 emit_move_insn (gen_reg_rtx (word_mode), memref);
1516 emit_move_insn (memref, const0_rtx);
1519 /* Probe a range of stack addresses from FIRST to FIRST+SIZE, inclusive.
1520 FIRST is a constant and size is a Pmode RTX. These are offsets from the
1521 current stack pointer. STACK_GROWS_DOWNWARD says whether to add or
1522 subtract from the stack. If SIZE is constant, this is done
1523 with a fixed number of probes. Otherwise, we must make a loop. */
1525 #ifdef STACK_GROWS_DOWNWARD
1526 #define STACK_GROW_OP MINUS
1528 #define STACK_GROW_OP PLUS
1532 probe_stack_range (first, size)
1533 HOST_WIDE_INT first;
1536 /* First see if the front end has set up a function for us to call to
1538 if (stack_check_libfunc != 0)
1540 rtx addr = memory_address (QImode,
1541 gen_rtx (STACK_GROW_OP, Pmode,
1543 plus_constant (size, first)));
1545 #ifdef POINTERS_EXTEND_UNSIGNED
1546 if (GET_MODE (addr) != ptr_mode)
1547 addr = convert_memory_address (ptr_mode, addr);
1550 emit_library_call (stack_check_libfunc, 0, VOIDmode, 1, addr,
1554 /* Next see if we have an insn to check the stack. Use it if so. */
1555 #ifdef HAVE_check_stack
1556 else if (HAVE_check_stack)
1558 insn_operand_predicate_fn pred;
1560 = force_operand (gen_rtx_STACK_GROW_OP (Pmode,
1562 plus_constant (size, first)),
1565 pred = insn_data[(int) CODE_FOR_check_stack].operand[0].predicate;
1566 if (pred && ! ((*pred) (last_addr, Pmode)))
1567 last_addr = copy_to_mode_reg (Pmode, last_addr);
1569 emit_insn (gen_check_stack (last_addr));
1573 /* If we have to generate explicit probes, see if we have a constant
1574 small number of them to generate. If so, that's the easy case. */
1575 else if (GET_CODE (size) == CONST_INT
1576 && INTVAL (size) < 10 * STACK_CHECK_PROBE_INTERVAL)
1578 HOST_WIDE_INT offset;
1580 /* Start probing at FIRST + N * STACK_CHECK_PROBE_INTERVAL
1581 for values of N from 1 until it exceeds LAST. If only one
1582 probe is needed, this will not generate any code. Then probe
1584 for (offset = first + STACK_CHECK_PROBE_INTERVAL;
1585 offset < INTVAL (size);
1586 offset = offset + STACK_CHECK_PROBE_INTERVAL)
1587 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1591 emit_stack_probe (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1593 plus_constant (size, first)));
1596 /* In the variable case, do the same as above, but in a loop. We emit loop
1597 notes so that loop optimization can be done. */
1601 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1603 GEN_INT (first + STACK_CHECK_PROBE_INTERVAL)),
1606 = force_operand (gen_rtx_fmt_ee (STACK_GROW_OP, Pmode,
1608 plus_constant (size, first)),
1610 rtx incr = GEN_INT (STACK_CHECK_PROBE_INTERVAL);
1611 rtx loop_lab = gen_label_rtx ();
1612 rtx test_lab = gen_label_rtx ();
1613 rtx end_lab = gen_label_rtx ();
1616 if (GET_CODE (test_addr) != REG
1617 || REGNO (test_addr) < FIRST_PSEUDO_REGISTER)
1618 test_addr = force_reg (Pmode, test_addr);
1620 emit_note (NULL, NOTE_INSN_LOOP_BEG);
1621 emit_jump (test_lab);
1623 emit_label (loop_lab);
1624 emit_stack_probe (test_addr);
1626 emit_note (NULL, NOTE_INSN_LOOP_CONT);
1628 #ifdef STACK_GROWS_DOWNWARD
1629 #define CMP_OPCODE GTU
1630 temp = expand_binop (Pmode, sub_optab, test_addr, incr, test_addr,
1633 #define CMP_OPCODE LTU
1634 temp = expand_binop (Pmode, add_optab, test_addr, incr, test_addr,
1638 if (temp != test_addr)
1641 emit_label (test_lab);
1642 emit_cmp_and_jump_insns (test_addr, last_addr, CMP_OPCODE,
1643 NULL_RTX, Pmode, 1, 0, loop_lab);
1644 emit_jump (end_lab);
1645 emit_note (NULL, NOTE_INSN_LOOP_END);
1646 emit_label (end_lab);
1648 emit_stack_probe (last_addr);
1652 /* Return an rtx representing the register or memory location
1653 in which a scalar value of data type VALTYPE
1654 was returned by a function call to function FUNC.
1655 FUNC is a FUNCTION_DECL node if the precise function is known,
1657 OUTGOING is 1 if on a machine with register windows this function
1658 should return the register in which the function will put its result
1662 hard_function_value (valtype, func, outgoing)
1664 tree func ATTRIBUTE_UNUSED;
1665 int outgoing ATTRIBUTE_UNUSED;
1669 #ifdef FUNCTION_OUTGOING_VALUE
1671 val = FUNCTION_OUTGOING_VALUE (valtype, func);
1674 val = FUNCTION_VALUE (valtype, func);
1676 if (GET_CODE (val) == REG
1677 && GET_MODE (val) == BLKmode)
1679 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype);
1680 enum machine_mode tmpmode;
1682 for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1683 tmpmode != VOIDmode;
1684 tmpmode = GET_MODE_WIDER_MODE (tmpmode))
1686 /* Have we found a large enough mode? */
1687 if (GET_MODE_SIZE (tmpmode) >= bytes)
1691 /* No suitable mode found. */
1692 if (tmpmode == VOIDmode)
1695 PUT_MODE (val, tmpmode);
1700 /* Return an rtx representing the register or memory location
1701 in which a scalar value of mode MODE was returned by a library call. */
1704 hard_libcall_value (mode)
1705 enum machine_mode mode;
1707 return LIBCALL_VALUE (mode);
1710 /* Look up the tree code for a given rtx code
1711 to provide the arithmetic operation for REAL_ARITHMETIC.
1712 The function returns an int because the caller may not know
1713 what `enum tree_code' means. */
1716 rtx_to_tree_code (code)
1719 enum tree_code tcode;
1742 tcode = LAST_AND_UNUSED_TREE_CODE;
1745 return ((int) tcode);