gcc/gcc/expr.c

7 the terms of the GNU General Public License as published by the Free
325      the required extension, strip it.  We don't handle such SUBREGs as
1026 /* Subroutine of move_by_pieces.  Move as many bytes as appropriate
1157   /* Set MEM_SIZE as appropriate for this block copy.  The main place this
1178 	 tree EXPR as addressable.  */
1302 	     here because if SIZE is less than the mode mask, as it is
1600    The new set has the same modes as the original set.  */
1630 /* A subroutine of emit_group_load.  Arguments as for emit_group_load,
1965       /* It is unclear if we can ever reach here, but we may as well handle
2467    a pointer which will be passed as argument in every CONSTFUN call.
2548    pointer which will be passed as argument in every CONSTFUN call.
2724 /* Subroutine of store_by_pieces_1.  Store as many bytes as appropriate
2782   /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
2964 	     here because if SIZE is less than the mode mask, as it is
3146    represented in NEW_MODE.  If FORCE is true, this will never happen, as
3192    an integer mode of the same size as MODE.  Returns the instruction
3329      hard regs shouldn't appear here except as return values.  */
3354      for floating point where we favor moving as parts if this is easy.  */
3441   /* The SUBREG_BYTE represents offset, as if the value were stored in
3443      SUBREG_BYTE to be 0; undo this exception as in
3530      hard regs shouldn't appear here except as return values.
3679    move as an extension.  */
3842    placing notes as appropriate.  PREV may be NULL, indicating the
3847      (2) One or more addition/subtraction with the SP as destination,
3848      (3) A single move insn with the SP as destination,
3892 	 as if it was a standalone insn.  */
4346       /* If we make space by pushing it, we might as well push
4449 /* Return X if X can be used as a subtarget in a sequence of arithmetic
4513       /* We want to eventually have OP0 be the same as TO, which
4911 	     This is only done for aligned data values, as these can
5023      This is needed for correct code for cases such as
5414      the same as that of TARGET, adjust the constant.  This is needed, for
5576 /* Same as store_expr_with_bounds but ignoring bounds of EXP.  */
5828    as "initializer_constant_valid_p (CTOR, TREE_TYPE (CTOR)) != 0".  */
5845    as a whole.  */
5905    TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
5906    CLEARED is as for store_constructor.
5974    may not be the same as the size of EXP if we are assigning to a field
6008 	   set the initial value as zero so we can fold the value into
6597       /* If the field isn't aligned enough to store as an ordinary memref,
6598 	 store it as a bit field.  */
6607 	 RHS isn't the same size as the bitfield, we must use bitfield
6625 	 implies a mask operation.  If the precision is the same size as
6765    look through nodes that serve as markers of a greater alignment than
6775    and specifically knows how to handle these nodes; as such, this is
6939   /* If OFFSET is constant, see if we can return the whole thing as a
6958       /* Avoid returning a negative bitpos as this may wreak havoc later.  */
7028      substituting for a PLACEHOLDER_EXPR as needed.  */
7082      for a PLACEHOLDER_EXPR as needed.  */
7171   /* Use subtarget as the target for operand 0 of a binary operation.  */
7317    for EXP, as opposed to a recursive call to this function.
7533    taken into account.  Assume it is at least as aligned as its
7610    MODIFIER argument is as documented by expand_expr.  */
7636 /* Return a MEM that contains constant EXP.  DEFER is as for
7637    output_constant_def and MODIFIER is as for expand_expr.  */
7651    The TARGET, TMODE and MODIFIER arguments are as for expand_expr.  */
7655 		         enum expand_modifier modifier, addr_space_t as)
7702 	 the address is the same as the address of the parent object.  */
7726 					target, tmode, modifier, as);
7730 	 expand_expr, as that can have various side effects; LABEL_DECLs for
7770       /* Pass FALSE as the last argument to get_inner_reference although
7794   result = expand_expr_addr_expr_1 (inner, subtarget, tmode, modifier, as);
7811       result = convert_memory_address_addr_space (tmode, result, as);
7812       tmp = convert_memory_address_addr_space (tmode, tmp, as);
7830       result = convert_memory_address_addr_space (tmode, result, as);
7840    The TARGET, TMODE and MODIFIER arguments are as for expand_expr.  */
7846   addr_space_t as = ADDR_SPACE_GENERIC;
7858       as = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (exp)));
7859       address_mode = targetm.addr_space.address_mode (as);
7860       pointer_mode = targetm.addr_space.pointer_mode (as);
7870 				    tmode, modifier, as);
7879     result = convert_memory_address_addr_space (tmode, result, as);
7915      initializer and all operands are constant, put it in memory as
7971    the rtx returned may not be the same as TARGET.
7987    products as above, or REG or MEM, or constant.
7992    it also marks a label as absolutely required (it can't be dead).
8001    a call parameter.  Such targets require special care as we haven't yet
8193   /* Use subtarget as the target for operand 0 of a binary operation.  */
8449 	 as pointer subtraction.  */
8651 	/* If there is no insn for FMA, emit it as __builtin_fma{,f,l}
8973 	 for unsigned bitfield expand this as XOR with a proper constant
9055 	   /* Make sure we don't have a hard reg (such as function's return
9316 	 if a target was specified use it; it will not be used as an
9369   /* Bitwise operations do not need bitfield reduction as we expect their
9381    Never consider memory loads as replaceable, because those don't ever lead
9496   /* Use subtarget as the target for operand 0 of a binary operation.  */
9519          out-of-ssa.  So fake instructions as if this was an access to the
9612       /* Ensure variable marked as used even if it doesn't go through
9847 	addr_space_t as
9852 	op0 = addr_for_mem_ref (exp, as, true);
9853 	op0 = memory_address_addr_space (mode, op0, as);
9856 	set_mem_addr_space (temp, as);
9882 	addr_space_t as
9914 	address_mode = targetm.addr_space.address_mode (as);
9925 	op0 = memory_address_addr_space (mode, op0, as);
9930 	    op0 = memory_address_addr_space (mode, op0, as);
9934 	set_mem_addr_space (temp, as);
10300 	   record its alignment as BIGGEST_ALIGNMENT.  */
10315 	   as a field, we might be extracting a BLKmode value from
10317 	   by doing the extract into an object as wide as the field
10335 	    /* If the field isn't aligned enough to fetch as a memref,
10336 	       fetch it as a bit field.  */
10350 	       size of the type isn't the same size as the bitfield,
10395 	       return 0 for the sake of consistency, as reading a zero-sized
10438 	   now as well.  */
10459 	   be marked as addressable through MEM_EXPR of the temporary.  */
10789       /* Function descriptors are not valid except for as
11080      are rarely passed as the first operand.  */