Re: [3/5] MEM_SIZE and MEM_SIZE_KNOWN_P

[Richard Guenther <richard dot guenther at gmail dot com>]

On Sun, Jul 17, 2011 at 4:31 PM, Richard Sandiford
<rdsandiford@googlemail.com> wrote:
> This patch does the mechanical MEM_SIZE interface change. ?It also
> makes set_mem_size take a HOST_WIDE_INT, and adds clear_mem_size
> for resetting the size to "unknown".
>
> The i386.c part includes an obvious pasto fix for:
>
> ?if (dst_size)
> ? ?set_mem_size (dst, GEN_INT (INTVAL (dst_size) - align_bytes));
> ?if (src_size)
> ? ?set_mem_size (dst, GEN_INT (INTVAL (src_size) - align_bytes));
>
> (last "dst" should be "src") which I can split out into a separate
> patch if desired.

Ok if there are no objections from target maintainers.

Thanks,
Richard.

> Richard
>
>
> gcc/
> ? ? ? ?* doc/rtl.texi (MEM_SIZE_KNOWN_P): Document.
> ? ? ? ?(MEM_SIZE): Change from returning an rtx to returning a HOST_WIDE_INT.
> ? ? ? ?* rtl.h (MEM_SIZE_KNOWN_P): New macro.
> ? ? ? ?(MEM_SIZE): Return a HOST_WIDE_INT rather than an rtx.
> ? ? ? ?* emit-rtl.h (set_mem_size): Take a HOST_WIDE_INT rather than an rtx.
> ? ? ? ?(clear_mem_size): Declare.
> ? ? ? ?* emit-rtl.c (set_mem_size): Take a HOST_WIDE_INT rather than an rtx.
> ? ? ? ?(clear_mem_size): New function.
> ? ? ? ?* alias.c (ao_ref_from_mem): Adjust uses of MEM_SIZE, using
> ? ? ? ?MEM_SIZE_KNOWN_P to test whether the size is known, and MEM_SIZE
> ? ? ? ?to get a HOST_WIDE_INT size. ?Adjust calls to set_mem_size,
> ? ? ? ?passing a HOST_WIDE_INT rather than an rtx. ?Use clear_mem_size
> ? ? ? ?to clear the size.
> ? ? ? ?(nonoverlapping_memrefs_p): Likewise.
> ? ? ? ?* builtins.c (get_memory_rtx, expand_builtin_memcmp): Likewise.
> ? ? ? ?(expand_builtin_init_trampoline): Likewise.
> ? ? ? ?* calls.c (compute_argument_addresses): Likewise.
> ? ? ? ?* cfgcleanup.c (merge_memattrs): Likewise.
> ? ? ? ?* dce.c (find_call_stack_args): Likewise.
> ? ? ? ?* dse.c (record_store, scan_insn): Likewise.
> ? ? ? ?* dwarf2out.c (dw_sra_loc_expr): Likewise.
> ? ? ? ?* expr.c (emit_block_move_hints): Likewise.
> ? ? ? ?* function.c (assign_parm_find_stack_rtl): Likewise.
> ? ? ? ?* print-rtl.c (print_rtx): Likewise.
> ? ? ? ?* reload.c (find_reloads_subreg_address): Likewise.
> ? ? ? ?* rtlanal.c (may_trap_p_1): Likewise.
> ? ? ? ?* var-tracking.c (track_expr_p): Likewise.
> ? ? ? ?* varasm.c (assemble_trampoline_template): Likewise.
> ? ? ? ?* config/arm/arm.c (arm_print_operand): Likewise.
> ? ? ? ?* config/h8300/h8300.c (h8sx_emit_movmd): Likewise.
> ? ? ? ?* config/i386/i386.c (expand_movmem_via_rep_mov): Likewise.
> ? ? ? ?(expand_setmem_via_rep_stos, expand_constant_movmem_prologue)
> ? ? ? ?(expand_constant_setmem_prologue): Likewise.
> ? ? ? ?* config/mips/mips.c (mips_get_unaligned_mem): Likewise.
> ? ? ? ?* config/rs6000/rs6000.c (expand_block_move): Likewise.
> ? ? ? ?(adjacent_mem_locations): Likewise.
> ? ? ? ?* config/s390/s390.c (s390_expand_setmem): Likewise.
> ? ? ? ?(s390_expand_insv): Likewise.
> ? ? ? ?* config/s390/s390.md (*extzv<mode>, *extv<mode>): Likewise.
> ? ? ? ?(*extendqi<mode>2_short_displ): Likewise.
> ? ? ? ?* config/sh/sh.c (expand_block_move): Likewise.
> ? ? ? ?* config/sh/sh.md (extv, extzv): Likewise.
>
> Index: gcc/doc/rtl.texi
> ===================================================================
> --- gcc/doc/rtl.texi ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/doc/rtl.texi ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -413,11 +413,17 @@ object associated with the reference.
> ?@item MEM_OFFSET (@var{x})
> ?The offset from the start of @code{MEM_EXPR} as a @code{CONST_INT} rtx.
>
> +@findex MEM_SIZE_KNOWN_P
> +@item MEM_SIZE_KNOWN_P (@var{x})
> +True if the size of the memory reference is known.
> +@samp{MEM_SIZE (@var{x})} provides its size if so.
> +
> ?@findex MEM_SIZE
> ?@item MEM_SIZE (@var{x})
> -The size in bytes of the memory reference as a @code{CONST_INT} rtx.
> +The size in bytes of the memory reference.
> ?This is mostly relevant for @code{BLKmode} references as otherwise
> -the size is implied by the mode.
> +the size is implied by the mode. ?The value is only valid if
> +@samp{MEM_SIZE_KNOWN_P (@var{x})} is true.
>
> ?@findex MEM_ALIGN
> ?@item MEM_ALIGN (@var{x})
> Index: gcc/rtl.h
> ===================================================================
> --- gcc/rtl.h ? 2011-07-17 11:40:12.000000000 +0100
> +++ gcc/rtl.h ? 2011-07-17 13:19:35.000000000 +0100
> @@ -1309,9 +1309,11 @@ #define MEM_OFFSET(RTX) (get_mem_attrs (
> ?/* For a MEM rtx, the address space. ?*/
> ?#define MEM_ADDR_SPACE(RTX) (get_mem_attrs (RTX)->addrspace)
>
> -/* For a MEM rtx, the size in bytes of the MEM, if known, as an RTX that
> - ? is always a CONST_INT. ?*/
> -#define MEM_SIZE(RTX) (get_mem_attrs (RTX)->size)
> +/* For a MEM rtx, true if its MEM_SIZE is known. ?*/
> +#define MEM_SIZE_KNOWN_P(RTX) (get_mem_attrs (RTX)->size != NULL_RTX)
> +
> +/* For a MEM rtx, the size in bytes of the MEM. ?*/
> +#define MEM_SIZE(RTX) INTVAL (get_mem_attrs (RTX)->size)
>
> ?/* For a MEM rtx, the alignment in bits. ?We can use the alignment of the
> ? ?mode as a default when STRICT_ALIGNMENT, but not if not. ?*/
> Index: gcc/emit-rtl.h
> ===================================================================
> --- gcc/emit-rtl.h ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/emit-rtl.h ? ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -36,7 +36,10 @@ extern void set_mem_expr (rtx, tree);
> ?extern void set_mem_offset (rtx, rtx);
>
> ?/* Set the size for MEM to SIZE. ?*/
> -extern void set_mem_size (rtx, rtx);
> +extern void set_mem_size (rtx, HOST_WIDE_INT);
> +
> +/* Clear the size recorded for MEM. ?*/
> +extern void clear_mem_size (rtx);
>
> ?/* Set the attributes for MEM appropriate for a spill slot. ?*/
> ?extern void set_mem_attrs_for_spill (rtx);
> Index: gcc/emit-rtl.c
> ===================================================================
> --- gcc/emit-rtl.c ? ? ?2011-07-17 11:40:13.000000000 +0100
> +++ gcc/emit-rtl.c ? ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -1913,12 +1913,24 @@ set_mem_offset (rtx mem, rtx offset)
> ?/* Set the size of MEM to SIZE. ?*/
>
> ?void
> -set_mem_size (rtx mem, rtx size)
> +set_mem_size (rtx mem, HOST_WIDE_INT size)
> ?{
> ? struct mem_attrs attrs;
>
> ? attrs = *get_mem_attrs (mem);
> - ?attrs.size = size;
> + ?attrs.size = GEN_INT (size);
> + ?set_mem_attrs (mem, &attrs);
> +}
> +
> +/* Clear the size of MEM. ?*/
> +
> +void
> +clear_mem_size (rtx mem)
> +{
> + ?struct mem_attrs attrs;
> +
> + ?attrs = *get_mem_attrs (mem);
> + ?attrs.size = NULL_RTX;
> ? set_mem_attrs (mem, &attrs);
> ?}
>
> Index: gcc/alias.c
> ===================================================================
> --- gcc/alias.c 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/alias.c 2011-07-17 13:19:35.000000000 +0100
> @@ -313,10 +313,10 @@ ao_ref_from_mem (ao_ref *ref, const_rtx
>
> ? ref->ref_alias_set = MEM_ALIAS_SET (mem);
>
> - ?/* If MEM_OFFSET or MEM_SIZE are NULL we have to punt.
> + ?/* If MEM_OFFSET or MEM_SIZE are unknown we have to punt.
> ? ? ?Keep points-to related information though. ?*/
> ? if (!MEM_OFFSET (mem)
> - ? ? ?|| !MEM_SIZE (mem))
> + ? ? ?|| !MEM_SIZE_KNOWN_P (mem))
> ? ? {
> ? ? ? ref->ref = NULL_TREE;
> ? ? ? ref->offset = 0;
> @@ -329,12 +329,12 @@ ao_ref_from_mem (ao_ref *ref, const_rtx
> ? ? ?case of promoted subregs on bigendian targets. ?Trust the MEM_EXPR
> ? ? ?here. ?*/
> ? if (INTVAL (MEM_OFFSET (mem)) < 0
> - ? ? ?&& ((INTVAL (MEM_SIZE (mem)) + INTVAL (MEM_OFFSET (mem)))
> + ? ? ?&& ((MEM_SIZE (mem) + INTVAL (MEM_OFFSET (mem)))
> ? ? ? ? ?* BITS_PER_UNIT) == ref->size)
> ? ? return true;
>
> ? ref->offset += INTVAL (MEM_OFFSET (mem)) * BITS_PER_UNIT;
> - ?ref->size = INTVAL (MEM_SIZE (mem)) * BITS_PER_UNIT;
> + ?ref->size = MEM_SIZE (mem) * BITS_PER_UNIT;
>
> ? /* The MEM may extend into adjacent fields, so adjust max_size if
> ? ? ?necessary. ?*/
> @@ -2338,11 +2338,11 @@ nonoverlapping_memrefs_p (const_rtx x, c
> ? ? return 0;
>
> ? sizex = (!MEM_P (rtlx) ? (int) GET_MODE_SIZE (GET_MODE (rtlx))
> - ? ? ? ? ?: MEM_SIZE (rtlx) ? INTVAL (MEM_SIZE (rtlx))
> + ? ? ? ? ?: MEM_SIZE_KNOWN_P (rtlx) ? MEM_SIZE (rtlx)
> ? ? ? ? ? : -1);
> ? sizey = (!MEM_P (rtly) ? (int) GET_MODE_SIZE (GET_MODE (rtly))
> - ? ? ? ? ?: MEM_SIZE (rtly) ? INTVAL (MEM_SIZE (rtly)) :
> - ? ? ? ? ?-1);
> + ? ? ? ? ?: MEM_SIZE_KNOWN_P (rtly) ? MEM_SIZE (rtly)
> + ? ? ? ? ?: -1);
>
> ? /* If we have an offset for either memref, it can update the values computed
> ? ? ?above. ?*/
> @@ -2354,10 +2354,10 @@ nonoverlapping_memrefs_p (const_rtx x, c
> ? /* If a memref has both a size and an offset, we can use the smaller size.
> ? ? ?We can't do this if the offset isn't known because we must view this
> ? ? ?memref as being anywhere inside the DECL's MEM. ?*/
> - ?if (MEM_SIZE (x) && moffsetx)
> - ? ?sizex = INTVAL (MEM_SIZE (x));
> - ?if (MEM_SIZE (y) && moffsety)
> - ? ?sizey = INTVAL (MEM_SIZE (y));
> + ?if (MEM_SIZE_KNOWN_P (x) && moffsetx)
> + ? ?sizex = MEM_SIZE (x);
> + ?if (MEM_SIZE_KNOWN_P (y) && moffsety)
> + ? ?sizey = MEM_SIZE (y);
>
> ? /* Put the values of the memref with the lower offset in X's values. ?*/
> ? if (offsetx > offsety)
> Index: gcc/builtins.c
> ===================================================================
> --- gcc/builtins.c ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/builtins.c ? ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -1299,7 +1299,7 @@ get_memory_rtx (tree exp, tree len)
> ? ? ? ? ? ?}
> ? ? ? ?}
> ? ? ? set_mem_alias_set (mem, 0);
> - ? ? ?set_mem_size (mem, NULL_RTX);
> + ? ? ?clear_mem_size (mem);
> ? ? }
>
> ? return mem;
> @@ -3691,8 +3691,8 @@ expand_builtin_memcmp (tree exp, ATTRIBU
> ? ? /* Set MEM_SIZE as appropriate. ?*/
> ? ? if (CONST_INT_P (arg3_rtx))
> ? ? ? {
> - ? ? ? set_mem_size (arg1_rtx, arg3_rtx);
> - ? ? ? set_mem_size (arg2_rtx, arg3_rtx);
> + ? ? ? set_mem_size (arg1_rtx, INTVAL (arg3_rtx));
> + ? ? ? set_mem_size (arg2_rtx, INTVAL (arg3_rtx));
> ? ? ? }
>
> ?#ifdef HAVE_cmpmemsi
> @@ -4838,7 +4838,7 @@ expand_builtin_init_trampoline (tree exp
> ? ? {
> ? ? ? m_tramp = change_address (m_tramp, BLKmode, tmp);
> ? ? ? set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
> - ? ? ?set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
> + ? ? ?set_mem_size (m_tramp, TRAMPOLINE_SIZE);
> ? ? }
>
> ? /* The FUNC argument should be the address of the nested function.
> Index: gcc/calls.c
> ===================================================================
> --- gcc/calls.c 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/calls.c 2011-07-17 11:40:14.000000000 +0100
> @@ -1481,7 +1481,7 @@ compute_argument_addresses (struct arg_d
> ? ? ? ? ? ? ?partial_mode = mode_for_size (units_on_stack * BITS_PER_UNIT,
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?MODE_INT, 1);
> ? ? ? ? ? ? ?args[i].stack = gen_rtx_MEM (partial_mode, addr);
> - ? ? ? ? ? ? set_mem_size (args[i].stack, GEN_INT (units_on_stack));
> + ? ? ? ? ? ? set_mem_size (args[i].stack, units_on_stack);
> ? ? ? ? ? ?}
> ? ? ? ? ?else
> ? ? ? ? ? ?{
> @@ -1513,7 +1513,7 @@ compute_argument_addresses (struct arg_d
> ? ? ? ? ? ? ? ? Generate a simple memory reference of the correct size.
> ? ? ? ? ? ? ? */
> ? ? ? ? ? ? ?args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
> - ? ? ? ? ? ? set_mem_size (args[i].stack_slot, GEN_INT (units_on_stack));
> + ? ? ? ? ? ? set_mem_size (args[i].stack_slot, units_on_stack);
> ? ? ? ? ? ?}
> ? ? ? ? ?else
> ? ? ? ? ? ?{
> Index: gcc/cfgcleanup.c
> ===================================================================
> --- gcc/cfgcleanup.c ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/cfgcleanup.c ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -883,7 +883,7 @@ merge_memattrs (rtx x, rtx y)
> ? ? ? ?MEM_ATTRS (x) = 0;
> ? ? ? else
> ? ? ? ?{
> - ? ? ? ? rtx mem_size;
> + ? ? ? ? HOST_WIDE_INT mem_size;
>
> ? ? ? ? ?if (MEM_ALIAS_SET (x) != MEM_ALIAS_SET (y))
> ? ? ? ? ? ?{
> @@ -904,15 +904,17 @@ merge_memattrs (rtx x, rtx y)
> ? ? ? ? ? ? ?set_mem_offset (y, 0);
> ? ? ? ? ? ?}
>
> - ? ? ? ? if (!MEM_SIZE (x))
> - ? ? ? ? ? mem_size = NULL_RTX;
> - ? ? ? ? else if (!MEM_SIZE (y))
> - ? ? ? ? ? mem_size = NULL_RTX;
> + ? ? ? ? if (MEM_SIZE_KNOWN_P (x) && MEM_SIZE_KNOWN_P (y))
> + ? ? ? ? ? {
> + ? ? ? ? ? ? mem_size = MAX (MEM_SIZE (x), MEM_SIZE (y));
> + ? ? ? ? ? ? set_mem_size (x, mem_size);
> + ? ? ? ? ? ? set_mem_size (y, mem_size);
> + ? ? ? ? ? }
> ? ? ? ? ?else
> - ? ? ? ? ? mem_size = GEN_INT (MAX (INTVAL (MEM_SIZE (x)),
> - ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?INTVAL (MEM_SIZE (y))));
> - ? ? ? ? set_mem_size (x, mem_size);
> - ? ? ? ? set_mem_size (y, mem_size);
> + ? ? ? ? ? {
> + ? ? ? ? ? ? clear_mem_size (x);
> + ? ? ? ? ? ? clear_mem_size (y);
> + ? ? ? ? ? }
>
> ? ? ? ? ?set_mem_align (x, MIN (MEM_ALIGN (x), MEM_ALIGN (y)));
> ? ? ? ? ?set_mem_align (y, MEM_ALIGN (x));
> Index: gcc/dce.c
> ===================================================================
> --- gcc/dce.c ? 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/dce.c ? 2011-07-17 11:40:14.000000000 +0100
> @@ -275,11 +275,11 @@ find_call_stack_args (rtx call_insn, boo
> ? ? if (GET_CODE (XEXP (p, 0)) == USE
> ? ? ? ?&& MEM_P (XEXP (XEXP (p, 0), 0)))
> ? ? ? {
> - ? ? ? rtx mem = XEXP (XEXP (p, 0), 0), addr, size;
> - ? ? ? HOST_WIDE_INT off = 0;
> - ? ? ? size = MEM_SIZE (mem);
> - ? ? ? if (size == NULL_RTX)
> + ? ? ? rtx mem = XEXP (XEXP (p, 0), 0), addr;
> + ? ? ? HOST_WIDE_INT off = 0, size;
> + ? ? ? if (!MEM_SIZE_KNOWN_P (mem))
> ? ? ? ? ?return false;
> + ? ? ? size = MEM_SIZE (mem);
> ? ? ? ?addr = XEXP (mem, 0);
> ? ? ? ?if (GET_CODE (addr) == PLUS
> ? ? ? ? ? ?&& REG_P (XEXP (addr, 0))
> @@ -329,7 +329,7 @@ find_call_stack_args (rtx call_insn, boo
> ? ? ? ? ? ? ?return false;
> ? ? ? ? ?}
> ? ? ? ?min_sp_off = MIN (min_sp_off, off);
> - ? ? ? max_sp_off = MAX (max_sp_off, off + INTVAL (size));
> + ? ? ? max_sp_off = MAX (max_sp_off, off + size);
> ? ? ? }
>
> ? if (min_sp_off >= max_sp_off)
> @@ -370,7 +370,7 @@ find_call_stack_args (rtx call_insn, boo
> ? ? ? ? ? ?set = single_set (DF_REF_INSN (defs->ref));
> ? ? ? ? ? ?off += INTVAL (XEXP (SET_SRC (set), 1));
> ? ? ? ? ?}
> - ? ? ? for (byte = off; byte < off + INTVAL (MEM_SIZE (mem)); byte++)
> + ? ? ? for (byte = off; byte < off + MEM_SIZE (mem); byte++)
> ? ? ? ? ?{
> ? ? ? ? ? ?if (!bitmap_set_bit (sp_bytes, byte - min_sp_off))
> ? ? ? ? ? ? ?gcc_unreachable ();
> Index: gcc/dse.c
> ===================================================================
> --- gcc/dse.c ? 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/dse.c ? 2011-07-17 11:40:14.000000000 +0100
> @@ -1355,11 +1355,10 @@ record_store (rtx body, bb_info_t bb_inf
> ? ? ? ?}
> ? ? ? /* Handle (set (mem:BLK (addr) [... S36 ...]) (const_int 0))
> ? ? ? ? as memset (addr, 0, 36); ?*/
> - ? ? ?else if (!MEM_SIZE (mem)
> - ? ? ? ? ? ? ?|| !CONST_INT_P (MEM_SIZE (mem))
> + ? ? ?else if (!MEM_SIZE_KNOWN_P (mem)
> + ? ? ? ? ? ? ?|| MEM_SIZE (mem) <= 0
> + ? ? ? ? ? ? ?|| MEM_SIZE (mem) > MAX_OFFSET
> ? ? ? ? ? ? ? || GET_CODE (body) != SET
> - ? ? ? ? ? ? ?|| INTVAL (MEM_SIZE (mem)) <= 0
> - ? ? ? ? ? ? ?|| INTVAL (MEM_SIZE (mem)) > MAX_OFFSET
> ? ? ? ? ? ? ? || !CONST_INT_P (SET_SRC (body)))
> ? ? ? ?{
> ? ? ? ? ?if (!store_is_unused)
> @@ -1384,7 +1383,7 @@ record_store (rtx body, bb_info_t bb_inf
> ? ? }
>
> ? if (GET_MODE (mem) == BLKmode)
> - ? ?width = INTVAL (MEM_SIZE (mem));
> + ? ?width = MEM_SIZE (mem);
> ? else
> ? ? {
> ? ? ? width = GET_MODE_SIZE (GET_MODE (mem));
> @@ -2517,7 +2516,7 @@ scan_insn (bb_info_t bb_info, rtx insn)
> ? ? ? ? ? ? ? ? ?&& INTVAL (args[2]) > 0)
> ? ? ? ? ? ? ? ?{
> ? ? ? ? ? ? ? ? ?rtx mem = gen_rtx_MEM (BLKmode, args[0]);
> - ? ? ? ? ? ? ? ? set_mem_size (mem, args[2]);
> + ? ? ? ? ? ? ? ? set_mem_size (mem, INTVAL (args[2]));
> ? ? ? ? ? ? ? ? ?body = gen_rtx_SET (VOIDmode, mem, args[1]);
> ? ? ? ? ? ? ? ? ?mems_found += record_store (body, bb_info);
> ? ? ? ? ? ? ? ? ?if (dump_file)
> Index: gcc/dwarf2out.c
> ===================================================================
> --- gcc/dwarf2out.c ? ? 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/dwarf2out.c ? ? 2011-07-17 13:19:35.000000000 +0100
> @@ -12876,7 +12876,7 @@ dw_sra_loc_expr (tree decl, rtx loc)
> ? ? ? ? ?if (MEM_P (varloc))
> ? ? ? ? ? ?{
> ? ? ? ? ? ? ?unsigned HOST_WIDE_INT memsize
> - ? ? ? ? ? ? ? = INTVAL (MEM_SIZE (varloc)) * BITS_PER_UNIT;
> + ? ? ? ? ? ? ? = MEM_SIZE (varloc) * BITS_PER_UNIT;
> ? ? ? ? ? ? ?if (memsize != bitsize)
> ? ? ? ? ? ? ? ?{
> ? ? ? ? ? ? ? ? ?if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
> Index: gcc/expr.c
> ===================================================================
> --- gcc/expr.c ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/expr.c ?2011-07-17 11:40:14.000000000 +0100
> @@ -1166,8 +1166,8 @@ emit_block_move_hints (rtx x, rtx y, rtx
> ? ? {
> ? ? ? x = shallow_copy_rtx (x);
> ? ? ? y = shallow_copy_rtx (y);
> - ? ? ?set_mem_size (x, size);
> - ? ? ?set_mem_size (y, size);
> + ? ? ?set_mem_size (x, INTVAL (size));
> + ? ? ?set_mem_size (y, INTVAL (size));
> ? ? }
>
> ? if (CONST_INT_P (size) && MOVE_BY_PIECES_P (INTVAL (size), align))
> Index: gcc/function.c
> ===================================================================
> --- gcc/function.c ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/function.c ? ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -2576,8 +2576,7 @@ assign_parm_find_stack_rtl (tree parm, s
> ? ? ? if (data->promoted_mode != BLKmode
> ? ? ? ? ?&& data->promoted_mode != DECL_MODE (parm))
> ? ? ? ?{
> - ? ? ? ? set_mem_size (stack_parm,
> - ? ? ? ? ? ? ? ? ? ? ? GEN_INT (GET_MODE_SIZE (data->promoted_mode)));
> + ? ? ? ? set_mem_size (stack_parm, GET_MODE_SIZE (data->promoted_mode));
> ? ? ? ? ?if (MEM_EXPR (stack_parm) && MEM_OFFSET (stack_parm))
> ? ? ? ? ? ?{
> ? ? ? ? ? ? ?int offset = subreg_lowpart_offset (DECL_MODE (parm),
> Index: gcc/print-rtl.c
> ===================================================================
> --- gcc/print-rtl.c ? ? 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/print-rtl.c ? ? 2011-07-17 13:19:35.000000000 +0100
> @@ -601,9 +601,8 @@ print_rtx (const_rtx in_rtx)
> ? ? ? ?fprintf (outfile, "+" HOST_WIDE_INT_PRINT_DEC,
> ? ? ? ? ? ? ? ? INTVAL (MEM_OFFSET (in_rtx)));
>
> - ? ? ?if (MEM_SIZE (in_rtx))
> - ? ? ? fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC,
> - ? ? ? ? ? ? ? ?INTVAL (MEM_SIZE (in_rtx)));
> + ? ? ?if (MEM_SIZE_KNOWN_P (in_rtx))
> + ? ? ? fprintf (outfile, " S" HOST_WIDE_INT_PRINT_DEC, MEM_SIZE (in_rtx));
>
> ? ? ? if (MEM_ALIGN (in_rtx) != 1)
> ? ? ? ?fprintf (outfile, " A%u", MEM_ALIGN (in_rtx));
> Index: gcc/reload.c
> ===================================================================
> --- gcc/reload.c ? ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/reload.c ? ? ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -6139,9 +6139,9 @@ find_reloads_subreg_address (rtx x, int
> ? ? ? ? ? ? ?PUT_MODE (tem, GET_MODE (x));
> ? ? ? ? ? ? ?if (MEM_OFFSET (tem))
> ? ? ? ? ? ? ? ?set_mem_offset (tem, plus_constant (MEM_OFFSET (tem), offset));
> - ? ? ? ? ? ? if (MEM_SIZE (tem)
> - ? ? ? ? ? ? ? ? && INTVAL (MEM_SIZE (tem)) != (HOST_WIDE_INT) outer_size)
> - ? ? ? ? ? ? ? set_mem_size (tem, GEN_INT (outer_size));
> + ? ? ? ? ? ? if (MEM_SIZE_KNOWN_P (tem)
> + ? ? ? ? ? ? ? ? && MEM_SIZE (tem) != (HOST_WIDE_INT) outer_size)
> + ? ? ? ? ? ? ? set_mem_size (tem, outer_size);
>
> ? ? ? ? ? ? ?/* If this was a paradoxical subreg that we replaced, the
> ? ? ? ? ? ? ? ? resulting memory must be sufficiently aligned to allow
> Index: gcc/rtlanal.c
> ===================================================================
> --- gcc/rtlanal.c ? ? ? 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/rtlanal.c ? ? ? 2011-07-17 11:40:14.000000000 +0100
> @@ -2279,7 +2279,7 @@ may_trap_p_1 (const_rtx x, unsigned flag
> ? ? ? ? ?code_changed
> ? ? ? ? ?|| !MEM_NOTRAP_P (x))
> ? ? ? ?{
> - ? ? ? ? HOST_WIDE_INT size = MEM_SIZE (x) ? INTVAL (MEM_SIZE (x)) : 0;
> + ? ? ? ? HOST_WIDE_INT size = MEM_SIZE_KNOWN_P (x) ? MEM_SIZE (x) : 0;
> ? ? ? ? ?return rtx_addr_can_trap_p_1 (XEXP (x, 0), 0, size,
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?GET_MODE (x), code_changed);
> ? ? ? ?}
> Index: gcc/var-tracking.c
> ===================================================================
> --- gcc/var-tracking.c ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/var-tracking.c ?2011-07-17 13:19:35.000000000 +0100
> @@ -4674,8 +4674,8 @@ track_expr_p (tree expr, bool need_rtl)
> ? ? ? if (GET_MODE (decl_rtl) == BLKmode
> ? ? ? ? ?|| AGGREGATE_TYPE_P (TREE_TYPE (realdecl)))
> ? ? ? ?return 0;
> - ? ? ?if (MEM_SIZE (decl_rtl)
> - ? ? ? ? && INTVAL (MEM_SIZE (decl_rtl)) > MAX_VAR_PARTS)
> + ? ? ?if (MEM_SIZE_KNOWN_P (decl_rtl)
> + ? ? ? ? && MEM_SIZE (decl_rtl) > MAX_VAR_PARTS)
> ? ? ? ?return 0;
> ? ? }
>
> Index: gcc/varasm.c
> ===================================================================
> --- gcc/varasm.c ? ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/varasm.c ? ? ? ?2011-07-17 11:40:14.000000000 +0100
> @@ -2391,7 +2391,7 @@ assemble_trampoline_template (void)
>
> ? initial_trampoline = gen_const_mem (BLKmode, symbol);
> ? set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
> - ?set_mem_size (initial_trampoline, GEN_INT (TRAMPOLINE_SIZE));
> + ?set_mem_size (initial_trampoline, TRAMPOLINE_SIZE);
>
> ? return initial_trampoline;
> ?}
> Index: gcc/config/arm/arm.c
> ===================================================================
> --- gcc/config/arm/arm.c ? ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/arm/arm.c ? ? ? ?2011-07-17 11:40:14.000000000 +0100
> @@ -16713,7 +16713,7 @@ arm_print_operand (FILE *stream, rtx x,
> ? ? ? ? ? instruction (for some alignments) as an aid to the memory subsystem
> ? ? ? ? ? of the target. ?*/
> ? ? ? ?align = MEM_ALIGN (x) >> 3;
> - ? ? ? memsize = INTVAL (MEM_SIZE (x));
> + ? ? ? memsize = MEM_SIZE (x);
>
> ? ? ? ?/* Only certain alignment specifiers are supported by the hardware. ?*/
> ? ? ? ?if (memsize == 16 && (align % 32) == 0)
> Index: gcc/config/h8300/h8300.c
> ===================================================================
> --- gcc/config/h8300/h8300.c ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/h8300/h8300.c ? ?2011-07-17 11:40:14.000000000 +0100
> @@ -2642,8 +2642,8 @@ h8sx_emit_movmd (rtx dest, rtx src, rtx
> ? ? ? first_dest = replace_equiv_address (dest, dest_reg);
> ? ? ? first_src = replace_equiv_address (src, src_reg);
>
> - ? ? ?set_mem_size (first_dest, GEN_INT (n & -factor));
> - ? ? ?set_mem_size (first_src, GEN_INT (n & -factor));
> + ? ? ?set_mem_size (first_dest, n & -factor);
> + ? ? ?set_mem_size (first_src, n & -factor);
>
> ? ? ? length = copy_to_mode_reg (HImode, gen_int_mode (n / factor, HImode));
> ? ? ? emit_insn (gen_movmd (first_dest, first_src, length, GEN_INT (factor)));
> Index: gcc/config/i386/i386.c
> ===================================================================
> --- gcc/config/i386/i386.c ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/i386/i386.c ? ? ?2011-07-17 11:40:14.000000000 +0100
> @@ -19702,6 +19702,7 @@ expand_movmem_via_rep_mov (rtx destmem,
> ? rtx destexp;
> ? rtx srcexp;
> ? rtx countreg;
> + ?HOST_WIDE_INT rounded_count;
>
> ? /* If the size is known, it is shorter to use rep movs. ?*/
> ? if (mode == QImode && CONST_INT_P (count)
> @@ -19729,19 +19730,19 @@ expand_movmem_via_rep_mov (rtx destmem,
> ? ? }
> ? if (CONST_INT_P (count))
> ? ? {
> - ? ? ?count = GEN_INT (INTVAL (count)
> + ? ? ?rounded_count = (INTVAL (count)
> ? ? ? ? ? ? ? ? ? ? ? & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
> ? ? ? destmem = shallow_copy_rtx (destmem);
> ? ? ? srcmem = shallow_copy_rtx (srcmem);
> - ? ? ?set_mem_size (destmem, count);
> - ? ? ?set_mem_size (srcmem, count);
> + ? ? ?set_mem_size (destmem, rounded_count);
> + ? ? ?set_mem_size (srcmem, rounded_count);
> ? ? }
> ? else
> ? ? {
> - ? ? ?if (MEM_SIZE (destmem))
> - ? ? ? set_mem_size (destmem, NULL_RTX);
> - ? ? ?if (MEM_SIZE (srcmem))
> - ? ? ? set_mem_size (srcmem, NULL_RTX);
> + ? ? ?if (MEM_SIZE_KNOWN_P (destmem))
> + ? ? ? clear_mem_size (destmem);
> + ? ? ?if (MEM_SIZE_KNOWN_P (srcmem))
> + ? ? ? clear_mem_size (srcmem);
> ? ? }
> ? emit_insn (gen_rep_mov (destptr, destmem, srcptr, srcmem, countreg,
> ? ? ? ? ? ? ? ? ? ? ? ? ?destexp, srcexp));
> @@ -19756,6 +19757,7 @@ expand_setmem_via_rep_stos (rtx destmem,
> ?{
> ? rtx destexp;
> ? rtx countreg;
> + ?HOST_WIDE_INT rounded_count;
>
> ? if (destptr != XEXP (destmem, 0) || GET_MODE (destmem) != BLKmode)
> ? ? destmem = adjust_automodify_address_nv (destmem, BLKmode, destptr, 0);
> @@ -19771,13 +19773,13 @@ expand_setmem_via_rep_stos (rtx destmem,
> ? ? destexp = gen_rtx_PLUS (Pmode, destptr, countreg);
> ? if (orig_value == const0_rtx && CONST_INT_P (count))
> ? ? {
> - ? ? ?count = GEN_INT (INTVAL (count)
> + ? ? ?rounded_count = (INTVAL (count)
> ? ? ? ? ? ? ? ? ? ? ? & ~((HOST_WIDE_INT) GET_MODE_SIZE (mode) - 1));
> ? ? ? destmem = shallow_copy_rtx (destmem);
> - ? ? ?set_mem_size (destmem, count);
> + ? ? ?set_mem_size (destmem, rounded_count);
> ? ? }
> - ?else if (MEM_SIZE (destmem))
> - ? ?set_mem_size (destmem, NULL_RTX);
> + ?else if (MEM_SIZE_KNOWN_P (destmem))
> + ? ?clear_mem_size (destmem);
> ? emit_insn (gen_rep_stos (destptr, countreg, destmem, value, destexp));
> ?}
>
> @@ -20118,13 +20120,12 @@ expand_constant_movmem_prologue (rtx dst
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? int desired_align, int align_bytes)
> ?{
> ? rtx src = *srcp;
> - ?rtx src_size, dst_size;
> + ?rtx orig_dst = dst;
> + ?rtx orig_src = src;
> ? int off = 0;
> ? int src_align_bytes = get_mem_align_offset (src, desired_align * BITS_PER_UNIT);
> ? if (src_align_bytes >= 0)
> ? ? src_align_bytes = desired_align - src_align_bytes;
> - ?src_size = MEM_SIZE (src);
> - ?dst_size = MEM_SIZE (dst);
> ? if (align_bytes & 1)
> ? ? {
> ? ? ? dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
> @@ -20182,10 +20183,10 @@ expand_constant_movmem_prologue (rtx dst
> ? ? ? if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT)
> ? ? ? ?set_mem_align (src, src_align * BITS_PER_UNIT);
> ? ? }
> - ?if (dst_size)
> - ? ?set_mem_size (dst, GEN_INT (INTVAL (dst_size) - align_bytes));
> - ?if (src_size)
> - ? ?set_mem_size (dst, GEN_INT (INTVAL (src_size) - align_bytes));
> + ?if (MEM_SIZE_KNOWN_P (orig_dst))
> + ? ?set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
> + ?if (MEM_SIZE_KNOWN_P (orig_src))
> + ? ?set_mem_size (src, MEM_SIZE (orig_src) - align_bytes);
> ? *srcp = src;
> ? return dst;
> ?}
> @@ -20233,7 +20234,7 @@ expand_constant_setmem_prologue (rtx dst
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? int desired_align, int align_bytes)
> ?{
> ? int off = 0;
> - ?rtx dst_size = MEM_SIZE (dst);
> + ?rtx orig_dst = dst;
> ? if (align_bytes & 1)
> ? ? {
> ? ? ? dst = adjust_automodify_address_nv (dst, QImode, destreg, 0);
> @@ -20262,8 +20263,8 @@ expand_constant_setmem_prologue (rtx dst
> ? dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off);
> ? if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT)
> ? ? set_mem_align (dst, desired_align * BITS_PER_UNIT);
> - ?if (dst_size)
> - ? ?set_mem_size (dst, GEN_INT (INTVAL (dst_size) - align_bytes));
> + ?if (MEM_SIZE_KNOWN_P (orig_dst))
> + ? ?set_mem_size (dst, MEM_SIZE (orig_dst) - align_bytes);
> ? return dst;
> ?}
>
> Index: gcc/config/mips/mips.c
> ===================================================================
> --- gcc/config/mips/mips.c ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/mips/mips.c ? ? ?2011-07-17 13:19:35.000000000 +0100
> @@ -6862,7 +6862,7 @@ mips_get_unaligned_mem (rtx *op, HOST_WI
> ? /* Adjust *OP to refer to the whole field. ?This also has the effect
> ? ? ?of legitimizing *OP's address for BLKmode, possibly simplifying it. ?*/
> ? *op = adjust_address (*op, BLKmode, 0);
> - ?set_mem_size (*op, GEN_INT (width / BITS_PER_UNIT));
> + ?set_mem_size (*op, width / BITS_PER_UNIT);
>
> ? /* Get references to both ends of the field. ?We deliberately don't
> ? ? ?use the original QImode *OP for FIRST since the new BLKmode one
> @@ -6962,13 +6962,9 @@ mips_expand_ins_as_unaligned_store (rtx
> ?bool
> ?mips_mem_fits_mode_p (enum machine_mode mode, rtx x)
> ?{
> - ?rtx size;
> -
> - ?if (!MEM_P (x))
> - ? ?return false;
> -
> - ?size = MEM_SIZE (x);
> - ?return size && INTVAL (size) == GET_MODE_SIZE (mode);
> + ?return (MEM_P (x)
> + ? ? ? ? && MEM_SIZE_KNOWN_P (x)
> + ? ? ? ? && MEM_SIZE (x) == GET_MODE_SIZE (mode));
> ?}
>
> ?/* Return true if (zero_extract OP WIDTH BITPOS) can be used as the
> Index: gcc/config/rs6000/rs6000.c
> ===================================================================
> --- gcc/config/rs6000/rs6000.c ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/rs6000/rs6000.c ?2011-07-17 11:40:14.000000000 +0100
> @@ -13685,14 +13685,14 @@ expand_block_move (rtx operands[])
> ? ? ? ? ? ? ?rtx src_reg = copy_addr_to_reg (XEXP (src, 0));
> ? ? ? ? ? ? ?src = replace_equiv_address (src, src_reg);
> ? ? ? ? ? ?}
> - ? ? ? ? set_mem_size (src, GEN_INT (move_bytes));
> + ? ? ? ? set_mem_size (src, move_bytes);
>
> ? ? ? ? ?if (!REG_P (XEXP (dest, 0)))
> ? ? ? ? ? ?{
> ? ? ? ? ? ? ?rtx dest_reg = copy_addr_to_reg (XEXP (dest, 0));
> ? ? ? ? ? ? ?dest = replace_equiv_address (dest, dest_reg);
> ? ? ? ? ? ?}
> - ? ? ? ? set_mem_size (dest, GEN_INT (move_bytes));
> + ? ? ? ? set_mem_size (dest, move_bytes);
>
> ? ? ? ? ?emit_insn ((*gen_func.movmemsi) (dest, src,
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? GEN_INT (move_bytes & 31),
> @@ -23063,8 +23063,8 @@ adjacent_mem_locations (rtx insn1, rtx i
> ? ? ? val_diff = val1 - val0;
>
> ? ? ? return ((REGNO (reg0) == REGNO (reg1))
> - ? ? ? ? ? ? && ((MEM_SIZE (a) && val_diff == INTVAL (MEM_SIZE (a)))
> - ? ? ? ? ? ? ? ? || (MEM_SIZE (b) && val_diff == -INTVAL (MEM_SIZE (b)))));
> + ? ? ? ? ? ? && ((MEM_SIZE_KNOWN_P (a) && val_diff == MEM_SIZE (a))
> + ? ? ? ? ? ? ? ? || (MEM_SIZE_KNOWN_P (b) && val_diff == -MEM_SIZE (b))));
> ? ? }
>
> ? return false;
> Index: gcc/config/s390/s390.c
> ===================================================================
> --- gcc/config/s390/s390.c ? ? ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/s390/s390.c ? ? ?2011-07-17 11:40:14.000000000 +0100
> @@ -4099,7 +4099,7 @@ s390_expand_setmem (rtx dst, rtx len, rt
> ? ? ? ? ? ? ? ? DST is set to size 1 so the rest of the memory location
> ? ? ? ? ? ? ? ? does not count as source operand. ?*/
> ? ? ? ? ? ? ?rtx dstp1 = adjust_address (dst, VOIDmode, 1);
> - ? ? ? ? ? ? set_mem_size (dst, const1_rtx);
> + ? ? ? ? ? ? set_mem_size (dst, 1);
>
> ? ? ? ? ? ? ?emit_insn (gen_movmem_short (dstp1, dst,
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? GEN_INT (INTVAL (len) - 2)));
> @@ -4142,7 +4142,7 @@ s390_expand_setmem (rtx dst, rtx len, rt
> ? ? ? else
> ? ? ? ?{
> ? ? ? ? ?dstp1 = adjust_address (dst, VOIDmode, 1);
> - ? ? ? ? set_mem_size (dst, const1_rtx);
> + ? ? ? ? set_mem_size (dst, 1);
>
> ? ? ? ? ?/* Initialize memory by storing the first byte. ?*/
> ? ? ? ? ?emit_move_insn (adjust_address (dst, QImode, 0), val);
> @@ -4551,7 +4551,7 @@ s390_expand_insv (rtx dest, rtx op1, rtx
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?GET_MODE_SIZE (word_mode) - size);
>
> ? ? ? ? ?dest = adjust_address (dest, BLKmode, 0);
> - ? ? ? ? set_mem_size (dest, GEN_INT (size));
> + ? ? ? ? set_mem_size (dest, size);
> ? ? ? ? ?s390_expand_movmem (dest, src_mem, GEN_INT (size));
> ? ? ? ?}
>
> @@ -4569,7 +4569,7 @@ s390_expand_insv (rtx dest, rtx op1, rtx
>
> ? ? ? ? ? ? ?emit_move_insn (adjust_address (dest, SImode, size),
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?gen_lowpart (SImode, src));
> - ? ? ? ? ? ? set_mem_size (dest, GEN_INT (size));
> + ? ? ? ? ? ? set_mem_size (dest, size);
> ? ? ? ? ? ? ?emit_move_insn (gen_rtx_ZERO_EXTRACT (word_mode, dest, GEN_INT
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?(stcmh_width), const0_rtx),
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?gen_rtx_LSHIFTRT (word_mode, src, GEN_INT
> Index: gcc/config/s390/s390.md
> ===================================================================
> --- gcc/config/s390/s390.md ? ? 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/s390/s390.md ? ? 2011-07-17 11:40:14.000000000 +0100
> @@ -3295,7 +3295,7 @@ (define_insn_and_split "*extzv<mode>"
> ? int mask = ((1ul << size) - 1) << (GET_MODE_SIZE (SImode) - size);
>
> ? operands[1] = adjust_address (operands[1], BLKmode, 0);
> - ?set_mem_size (operands[1], GEN_INT (size));
> + ?set_mem_size (operands[1], size);
> ? operands[2] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - bitsize);
> ? operands[3] = GEN_INT (mask);
> ?})
> @@ -3322,7 +3322,7 @@ (define_insn_and_split "*extv<mode>"
> ? int mask = ((1ul << size) - 1) << (GET_MODE_SIZE (SImode) - size);
>
> ? operands[1] = adjust_address (operands[1], BLKmode, 0);
> - ?set_mem_size (operands[1], GEN_INT (size));
> + ?set_mem_size (operands[1], size);
> ? operands[2] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode) - bitsize);
> ? operands[3] = GEN_INT (mask);
> ?})
> @@ -3656,7 +3656,7 @@ (define_insn_and_split "*extendqi<mode>2
> ? ? ?(clobber (reg:CC CC_REGNUM))])]
> ?{
> ? operands[1] = adjust_address (operands[1], BLKmode, 0);
> - ?set_mem_size (operands[1], GEN_INT (GET_MODE_SIZE (QImode)));
> + ?set_mem_size (operands[1], GET_MODE_SIZE (QImode));
> ? operands[2] = GEN_INT (GET_MODE_BITSIZE (<MODE>mode)
> ? ? ? ? ? ? ? ? ? ? ? ? - GET_MODE_BITSIZE (QImode));
> ?})
> Index: gcc/config/sh/sh.c
> ===================================================================
> --- gcc/config/sh/sh.c ?2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/sh/sh.c ?2011-07-17 11:40:14.000000000 +0100
> @@ -1456,7 +1456,7 @@ expand_block_move (rtx *operands)
> ? ? ? ? ?rtx from = adjust_automodify_address (src, BLKmode,
> ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?src_addr, copied);
>
> - ? ? ? ? set_mem_size (from, GEN_INT (4));
> + ? ? ? ? set_mem_size (from, 4);
> ? ? ? ? ?emit_insn (gen_movua (temp, from));
> ? ? ? ? ?emit_move_insn (src_addr, plus_constant (src_addr, 4));
> ? ? ? ? ?emit_move_insn (to, temp);
> Index: gcc/config/sh/sh.md
> ===================================================================
> --- gcc/config/sh/sh.md 2011-07-17 11:30:32.000000000 +0100
> +++ gcc/config/sh/sh.md 2011-07-17 11:40:14.000000000 +0100
> @@ -11070,7 +11070,7 @@ (define_expand "extv"
> ? ? ? && MEM_P (operands[1]) && MEM_ALIGN (operands[1]) < 32)
> ? ? {
> ? ? ? rtx src = adjust_address (operands[1], BLKmode, 0);
> - ? ? ?set_mem_size (src, GEN_INT (4));
> + ? ? ?set_mem_size (src, 4);
> ? ? ? emit_insn (gen_movua (operands[0], src));
> ? ? ? DONE;
> ? ? }
> @@ -11102,7 +11102,7 @@ (define_expand "extzv"
> ? ? ? && MEM_P (operands[1]) && MEM_ALIGN (operands[1]) < 32)
> ? ? {
> ? ? ? rtx src = adjust_address (operands[1], BLKmode, 0);
> - ? ? ?set_mem_size (src, GEN_INT (4));
> + ? ? ?set_mem_size (src, 4);
> ? ? ? emit_insn (gen_movua (operands[0], src));
> ? ? ? DONE;
> ? ? }
>