CbC/CbC_gcc: gcc/expr.c comparison

comparison gcc/expr.c @ 131:84e7813d76e9

gcc-8.2

author	mir3636
date	Thu, 25 Oct 2018 07:37:49 +0900
parents	04ced10e8804
children	1830386684a0

comparison

equal deleted inserted replaced

-:04ced10e8804
+:84e7813d76e9
 /* Convert tree expression to rtl instructions, for GNU compiler.
-Copyright (C) 1988-2017 Free Software Foundation, Inc.
+Copyright (C) 1988-2018 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
 #include "optabs-tree.h"
 #include "libfuncs.h"
 #include "reload.h"
 #include "langhooks.h"
 #include "common/common-target.h"
+#include "tree-dfa.h"
 #include "tree-ssa-live.h"
 #include "tree-outof-ssa.h"
 #include "tree-ssa-address.h"
 #include "builtins.h"
-#include "tree-chkp.h"
-#include "rtl-chkp.h"
 #include "ccmp.h"
+#include "gimple-fold.h"
+#include "rtx-vector-builder.h"
 /* If this is nonzero, we do not bother generating VOLATILE
 around volatile memory references, and we are willing to
 output indirect addresses.  If cse is to follow, we reject
 					unsigned HOST_WIDE_INT);
 static void emit_block_move_via_loop (rtx, rtx, rtx, unsigned);
 static void clear_by_pieces (rtx, unsigned HOST_WIDE_INT, unsigned int);
 static rtx_insn *compress_float_constant (rtx, rtx);
 static rtx get_subtarget (rtx);
-static void store_constructor_field (rtx, unsigned HOST_WIDE_INT,
+static void store_constructor (tree, rtx, int, poly_int64, bool);
-				     HOST_WIDE_INT, unsigned HOST_WIDE_INT,
+static rtx store_field (rtx, poly_int64, poly_int64, poly_uint64, poly_uint64,
-				     unsigned HOST_WIDE_INT, machine_mode,
-				     tree, int, alias_set_type, bool);
-static void store_constructor (tree, rtx, int, HOST_WIDE_INT, bool);
-static rtx store_field (rtx, HOST_WIDE_INT, HOST_WIDE_INT,
-			unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT,
 			machine_mode, tree, alias_set_type, bool, bool);
 static unsigned HOST_WIDE_INT highest_pow2_factor_for_target (const_tree, const_tree);
 static int is_aligning_offset (const_tree, const_tree);
 && SUBREG_PROMOTED_VAR_P (from)
 && is_a <scalar_int_mode> (to_mode, &to_int_mode)
 && (GET_MODE_PRECISION (subreg_promoted_mode (from))
 	  >= GET_MODE_PRECISION (to_int_mode))
 && SUBREG_CHECK_PROMOTED_SIGN (from, unsignedp))
-from = gen_lowpart (to_int_mode, from), from_mode = to_int_mode;
+{
+from = gen_lowpart (to_int_mode, SUBREG_REG (from));
+from_mode = to_int_mode;
+}
 gcc_assert (GET_CODE (to) != SUBREG || !SUBREG_PROMOTED_VAR_P (to));
 if (to_mode == from_mode
 || (from_mode == VOIDmode && CONSTANT_P (from)))
 return;
 }
 if (VECTOR_MODE_P (to_mode) || VECTOR_MODE_P (from_mode))
 {
-gcc_assert (GET_MODE_BITSIZE (from_mode) == GET_MODE_BITSIZE (to_mode));
+gcc_assert (known_eq (GET_MODE_BITSIZE (from_mode),
+			    GET_MODE_BITSIZE (to_mode)));
 if (VECTOR_MODE_P (to_mode))
 	from = simplify_gen_subreg (to_mode, from, GET_MODE (from), 0);
 else
 	to = simplify_gen_subreg (from_mode, to, GET_MODE (to), 0);
 scalar_int_mode int_oldmode;
 if (is_int_mode (mode, &int_mode)
 && is_int_mode (oldmode, &int_oldmode)
 && GET_MODE_PRECISION (int_mode) <= GET_MODE_PRECISION (int_oldmode)
 && ((MEM_P (x) && !MEM_VOLATILE_P (x) && direct_load[(int) int_mode])
+	  || CONST_POLY_INT_P (x)
 || (REG_P (x)
 && (!HARD_REGISTER_P (x)
 		  || targetm.hard_regno_mode_ok (REGNO (x), int_mode))
 && TRULY_NOOP_TRUNCATION_MODES_P (int_mode, GET_MODE (x)))))
 return gen_lowpart (int_mode, x);
 /* Converting from integer constant into mode is always equivalent to an
 subreg operation.  */
 if (VECTOR_MODE_P (mode) && GET_MODE (x) == VOIDmode)
 {
-gcc_assert (GET_MODE_BITSIZE (mode) == GET_MODE_BITSIZE (oldmode));
+gcc_assert (known_eq (GET_MODE_BITSIZE (mode),
+			    GET_MODE_BITSIZE (oldmode)));
 return simplify_gen_subreg (mode, x, oldmode, 0);
 }
 temp = gen_reg_rtx (mode);
 convert_move (temp, x, unsignedp);
 		       unsigned int expected_align, HOST_WIDE_INT expected_size,
 		       unsigned HOST_WIDE_INT min_size,
 		       unsigned HOST_WIDE_INT max_size,
 		       unsigned HOST_WIDE_INT probable_max_size)
 {
-bool may_use_call;
+int may_use_call;
 rtx retval = 0;
 unsigned int align;
 gcc_assert (size);
 if (CONST_INT_P (size) && INTVAL (size) == 0)
 switch (method)
 {
 case BLOCK_OP_NORMAL:
 case BLOCK_OP_TAILCALL:
-may_use_call = true;
+may_use_call = 1;
 break;
 case BLOCK_OP_CALL_PARM:
 may_use_call = block_move_libcall_safe_for_call_parm ();
 	 to force it to pop the arguments right away.  */
 NO_DEFER_POP;
 break;
 case BLOCK_OP_NO_LIBCALL:
-may_use_call = false;
+may_use_call = 0;
+break;
+case BLOCK_OP_NO_LIBCALL_RET:
+may_use_call = -1;
 break;
 default:
 gcc_unreachable ();
 }
 x = adjust_address (x, BLKmode, 0);
 y = adjust_address (y, BLKmode, 0);
 /* Set MEM_SIZE as appropriate for this block copy.  The main place this
 can be incorrect is coming from __builtin_memcpy.  */
-if (CONST_INT_P (size))
+poly_int64 const_size;
+if (poly_int_rtx_p (size, &const_size))
 {
 x = shallow_copy_rtx (x);
 y = shallow_copy_rtx (y);
-set_mem_size (x, INTVAL (size));
+set_mem_size (x, const_size);
-set_mem_size (y, INTVAL (size));
+set_mem_size (y, const_size);
 }
 if (CONST_INT_P (size) && can_move_by_pieces (INTVAL (size), align))
 move_by_pieces (x, y, INTVAL (size), align, 0);
 else if (emit_block_move_via_movmem (x, y, size, align,
 ;
 else if (may_use_call
 	   && ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (x))
 	   && ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (y)))
 {
+if (may_use_call < 0)
+	return pc_rtx;
 /* Since x and y are passed to a libcall, mark the corresponding
 	 tree EXPR as addressable.  */
 tree y_expr = MEM_EXPR (y);
 tree x_expr = MEM_EXPR (x);
 if (y_expr)
 /* A subroutine of emit_group_load.  Arguments as for emit_group_load,
 except that values are placed in TMPS[i], and must later be moved
 into corresponding XEXP (XVECEXP (DST, 0, i), 0) element.  */
 static void
-emit_group_load_1 (rtx *tmps, rtx dst, rtx orig_src, tree type, int ssize)
+emit_group_load_1 (rtx *tmps, rtx dst, rtx orig_src, tree type,
+		   poly_int64 ssize)
 {
 rtx src;
 int start, i;
 machine_mode m = GET_MODE (orig_src);
 /* Process the pieces.  */
 for (i = start; i < XVECLEN (dst, 0); i++)
 {
 machine_mode mode = GET_MODE (XEXP (XVECEXP (dst, 0, i), 0));
-HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (dst, 0, i), 1));
+poly_int64 bytepos = rtx_to_poly_int64 (XEXP (XVECEXP (dst, 0, i), 1));
-unsigned int bytelen = GET_MODE_SIZE (mode);
+poly_int64 bytelen = GET_MODE_SIZE (mode);
-int shift = 0;
+poly_int64 shift = 0;
-/* Handle trailing fragments that run over the size of the struct.  */
+/* Handle trailing fragments that run over the size of the struct.
-if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
+	 It's the target's responsibility to make sure that the fragment
+	 cannot be strictly smaller in some cases and strictly larger
+	 in others.  */
+gcc_checking_assert (ordered_p (bytepos + bytelen, ssize));
+if (known_size_p (ssize) && maybe_gt (bytepos + bytelen, ssize))
 	{
 	  /* Arrange to shift the fragment to where it belongs.
 	     extract_bit_field loads to the lsb of the reg.  */
 	  if (
 #ifdef BLOCK_REG_PADDING
 	      BYTES_BIG_ENDIAN
 #endif
 	      )
 	    shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
 	  bytelen = ssize - bytepos;
-	  gcc_assert (bytelen > 0);
+	  gcc_assert (maybe_gt (bytelen, 0));
 	}
 /* If we won't be loading directly from memory, protect the real source
 	 from strange tricks we might play; but make sure that the source can
 	 be loaded directly into the destination.  */
 /* Optimize the access just a bit.  */
 if (MEM_P (src)
 	  && (! targetm.slow_unaligned_access (mode, MEM_ALIGN (src))
 	      || MEM_ALIGN (src) >= GET_MODE_ALIGNMENT (mode))
-	  && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
+	  && multiple_p (bytepos * BITS_PER_UNIT, GET_MODE_ALIGNMENT (mode))
-	  && bytelen == GET_MODE_SIZE (mode))
+	  && known_eq (bytelen, GET_MODE_SIZE (mode)))
 	{
 	  tmps[i] = gen_reg_rtx (mode);
 	  emit_move_insn (tmps[i], adjust_address (src, mode, bytepos));
 	}
 else if (COMPLEX_MODE_P (mode)
 	       && GET_MODE (src) == mode
-	       && bytelen == GET_MODE_SIZE (mode))
+	       && known_eq (bytelen, GET_MODE_SIZE (mode)))
 	/* Let emit_move_complex do the bulk of the work.  */
 	tmps[i] = src;
 else if (GET_CODE (src) == CONCAT)
 	{
-	  unsigned int slen = GET_MODE_SIZE (GET_MODE (src));
+	  poly_int64 slen = GET_MODE_SIZE (GET_MODE (src));
-	  unsigned int slen0 = GET_MODE_SIZE (GET_MODE (XEXP (src, 0)));
+	  poly_int64 slen0 = GET_MODE_SIZE (GET_MODE (XEXP (src, 0)));
-	  unsigned int elt = bytepos / slen0;
+	  unsigned int elt;
-	  unsigned int subpos = bytepos % slen0;
+	  poly_int64 subpos;
-	  if (subpos + bytelen <= slen0)
+	  if (can_div_trunc_p (bytepos, slen0, &elt, &subpos)
+	      && known_le (subpos + bytelen, slen0))
 	    {
 	      /* The following assumes that the concatenated objects all
 		 have the same size.  In this case, a simple calculation
 		 can be used to determine the object and the bit field
 		 to be extracted.  */
 	      tmps[i] = XEXP (src, elt);
-	      if (subpos != 0
+	      if (maybe_ne (subpos, 0)
-		  || subpos + bytelen != slen0
+		  || maybe_ne (subpos + bytelen, slen0)
 		  || (!CONSTANT_P (tmps[i])
 		      && (!REG_P (tmps[i]) || GET_MODE (tmps[i]) != mode)))
 		tmps[i] = extract_bit_field (tmps[i], bytelen * BITS_PER_UNIT,
 					     subpos * BITS_PER_UNIT,
 					     1, NULL_RTX, mode, mode, false,
 	    }
 	  else
 	    {
 	      rtx mem;
-	      gcc_assert (!bytepos);
+	      gcc_assert (known_eq (bytepos, 0));
 	      mem = assign_stack_temp (GET_MODE (src), slen);
 	      emit_move_insn (mem, src);
 	      tmps[i] = extract_bit_field (mem, bytelen * BITS_PER_UNIT,
 					   0, 1, NULL_RTX, mode, mode, false,
 					   NULL);
 	 SIMD register, which is currently broken.  While we get GCC
 	 to emit proper RTL for these cases, let's dump to memory.  */
 else if (VECTOR_MODE_P (GET_MODE (dst))
 	       && REG_P (src))
 	{
-	  int slen = GET_MODE_SIZE (GET_MODE (src));
+	  poly_uint64 slen = GET_MODE_SIZE (GET_MODE (src));
 	  rtx mem;
 	  mem = assign_stack_temp (GET_MODE (src), slen);
 	  emit_move_insn (mem, src);
-	  tmps[i] = adjust_address (mem, mode, (int) bytepos);
+	  tmps[i] = adjust_address (mem, mode, bytepos);
 	}
 else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
 && XVECLEN (dst, 0) > 1)
 tmps[i] = simplify_gen_subreg (mode, src, GET_MODE (dst), bytepos);
 else if (CONSTANT_P (src))
 	{
-	  HOST_WIDE_INT len = (HOST_WIDE_INT) bytelen;
+	  if (known_eq (bytelen, ssize))
-	  if (len == ssize)
 	    tmps[i] = src;
 	  else
 	    {
 	      rtx first, second;
 	      /* TODO: const_wide_int can have sizes other than this...  */
-	      gcc_assert (2 * len == ssize);
+	      gcc_assert (known_eq (2 * bytelen, ssize));
 	      split_double (src, &first, &second);
 	      if (i)
 		tmps[i] = second;
 	      else
 		tmps[i] = first;
 else
 	tmps[i] = extract_bit_field (src, bytelen * BITS_PER_UNIT,
 				     bytepos * BITS_PER_UNIT, 1, NULL_RTX,
 				     mode, mode, false, NULL);
-if (shift)
+if (maybe_ne (shift, 0))
 	tmps[i] = expand_shift (LSHIFT_EXPR, mode, tmps[i],
 				shift, tmps[i], 0);
 }
 }
 where DST is non-consecutive registers represented by a PARALLEL.
 SSIZE represents the total size of block ORIG_SRC in bytes, or -1
 if not known.  */
 void
-emit_group_load (rtx dst, rtx src, tree type, int ssize)
+emit_group_load (rtx dst, rtx src, tree type, poly_int64 ssize)
 {
 rtx *tmps;
 int i;
 tmps = XALLOCAVEC (rtx, XVECLEN (dst, 0));
 /* Similar, but load SRC into new pseudos in a format that looks like
 PARALLEL.  This can later be fed to emit_group_move to get things
 in the right place.  */
 rtx
-emit_group_load_into_temps (rtx parallel, rtx src, tree type, int ssize)
+emit_group_load_into_temps (rtx parallel, rtx src, tree type, poly_int64 ssize)
 {
 rtvec vec;
 int i;
 vec = rtvec_alloc (XVECLEN (parallel, 0));
 where SRC is non-consecutive registers represented by a PARALLEL.
 SSIZE represents the total size of block ORIG_DST, or -1 if not
 known.  */
 void
-emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED, int ssize)
+emit_group_store (rtx orig_dst, rtx src, tree type ATTRIBUTE_UNUSED,
+		  poly_int64 ssize)
 {
 rtx *tmps, dst;
 int start, finish, i;
 machine_mode m = GET_MODE (orig_dst);
 }
 else if (!MEM_P (dst) && GET_CODE (dst) != CONCAT)
 {
 machine_mode outer = GET_MODE (dst);
 machine_mode inner;
-HOST_WIDE_INT bytepos;
+poly_int64 bytepos;
 bool done = false;
 rtx temp;
 if (!REG_P (dst) || REGNO (dst) < FIRST_PSEUDO_REGISTER)
 	dst = gen_reg_rtx (outer);
 	 initialize the destination.  */
 if (start < finish)
 	{
 	  inner = GET_MODE (tmps[start]);
 	  bytepos = subreg_lowpart_offset (inner, outer);
-	  if (INTVAL (XEXP (XVECEXP (src, 0, start), 1)) == bytepos)
+	  if (known_eq (rtx_to_poly_int64 (XEXP (XVECEXP (src, 0, start), 1)),
+			bytepos))
 	    {
 	      temp = simplify_gen_subreg (outer, tmps[start],
 					  inner, 0);
 	      if (temp)
 		{
 if (!done
 	  && start < finish - 1)
 	{
 	  inner = GET_MODE (tmps[finish - 1]);
 	  bytepos = subreg_lowpart_offset (inner, outer);
-	  if (INTVAL (XEXP (XVECEXP (src, 0, finish - 1), 1)) == bytepos)
+	  if (known_eq (rtx_to_poly_int64 (XEXP (XVECEXP (src, 0,
+							  finish - 1), 1)),
+			bytepos))
 	    {
 	      temp = simplify_gen_subreg (outer, tmps[finish - 1],
 					  inner, 0);
 	      if (temp)
 		{
 }
 /* Process the pieces.  */
 for (i = start; i < finish; i++)
 {
-HOST_WIDE_INT bytepos = INTVAL (XEXP (XVECEXP (src, 0, i), 1));
+poly_int64 bytepos = rtx_to_poly_int64 (XEXP (XVECEXP (src, 0, i), 1));
 machine_mode mode = GET_MODE (tmps[i]);
-unsigned int bytelen = GET_MODE_SIZE (mode);
+poly_int64 bytelen = GET_MODE_SIZE (mode);
-unsigned int adj_bytelen;
+poly_uint64 adj_bytelen;
 rtx dest = dst;
-/* Handle trailing fragments that run over the size of the struct.  */
+/* Handle trailing fragments that run over the size of the struct.
-if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
+	 It's the target's responsibility to make sure that the fragment
+	 cannot be strictly smaller in some cases and strictly larger
+	 in others.  */
+gcc_checking_assert (ordered_p (bytepos + bytelen, ssize));
+if (known_size_p (ssize) && maybe_gt (bytepos + bytelen, ssize))
 	adj_bytelen = ssize - bytepos;
 else
 	adj_bytelen = bytelen;
 if (GET_CODE (dst) == CONCAT)
 	{
-	  if (bytepos + adj_bytelen
+	  if (known_le (bytepos + adj_bytelen,
-	      <= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
+			GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)))))
 	    dest = XEXP (dst, 0);
-	  else if (bytepos >= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0))))
+	  else if (known_ge (bytepos, GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)))))
 	    {
 	      bytepos -= GET_MODE_SIZE (GET_MODE (XEXP (dst, 0)));
 	      dest = XEXP (dst, 1);
 	    }
 	  else
 	    {
 	      machine_mode dest_mode = GET_MODE (dest);
 	      machine_mode tmp_mode = GET_MODE (tmps[i]);
-	      gcc_assert (bytepos == 0 && XVECLEN (src, 0));
+	      gcc_assert (known_eq (bytepos, 0) && XVECLEN (src, 0));
 	      if (GET_MODE_ALIGNMENT (dest_mode)
 		  >= GET_MODE_ALIGNMENT (tmp_mode))
 		{
 		  dest = assign_stack_temp (dest_mode,
 	      break;
 	    }
 	}
 /* Handle trailing fragments that run over the size of the struct.  */
-if (ssize >= 0 && bytepos + (HOST_WIDE_INT) bytelen > ssize)
+if (known_size_p (ssize) && maybe_gt (bytepos + bytelen, ssize))
 	{
 	  /* store_bit_field always takes its value from the lsb.
 	     Move the fragment to the lsb if it's not already there.  */
 	  if (
 #ifdef BLOCK_REG_PADDING
 #else
 	      BYTES_BIG_ENDIAN
 #endif
 	      )
 	    {
-	      int shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
+	      poly_int64 shift = (bytelen - (ssize - bytepos)) * BITS_PER_UNIT;
 	      tmps[i] = expand_shift (RSHIFT_EXPR, mode, tmps[i],
 				      shift, tmps[i], 0);
 	    }
 	  /* Make sure not to write past the end of the struct.  */
 /* Optimize the access just a bit.  */
 else if (MEM_P (dest)
 	       && (!targetm.slow_unaligned_access (mode, MEM_ALIGN (dest))
 		   || MEM_ALIGN (dest) >= GET_MODE_ALIGNMENT (mode))
-	       && bytepos * BITS_PER_UNIT % GET_MODE_ALIGNMENT (mode) == 0
+	       && multiple_p (bytepos * BITS_PER_UNIT,
-	       && bytelen == GET_MODE_SIZE (mode))
+			      GET_MODE_ALIGNMENT (mode))
+	       && known_eq (bytelen, GET_MODE_SIZE (mode)))
 	emit_move_insn (adjust_address (dest, mode, bytepos), tmps[i]);
 else
 	store_bit_field (dest, bytelen * BITS_PER_UNIT, bytepos * BITS_PER_UNIT,
 			 0, 0, mode, tmps[i], false);
 {
 unsigned HOST_WIDE_INT bytes = int_size_in_bytes (type);
 rtx src = NULL, dst = NULL;
 unsigned HOST_WIDE_INT bitsize = MIN (TYPE_ALIGN (type), BITS_PER_WORD);
 unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0;
-machine_mode mode = GET_MODE (srcreg);
+/* No current ABI uses variable-sized modes to pass a BLKmnode type.  */
-machine_mode tmode = GET_MODE (target);
+fixed_size_mode mode = as_a <fixed_size_mode> (GET_MODE (srcreg));
-machine_mode copy_mode;
+fixed_size_mode tmode = as_a <fixed_size_mode> (GET_MODE (target));
+fixed_size_mode copy_mode;
 /* BLKmode registers created in the back-end shouldn't have survived.  */
 gcc_assert (mode != BLKmode);
 /* If the structure doesn't take up a whole number of words, see whether
 					  false, NULL),
 		       false);
 }
 }
-/* Copy BLKmode value SRC into a register of mode MODE.  Return the
+/* Copy BLKmode value SRC into a register of mode MODE_IN.  Return the
 register if it contains any data, otherwise return null.
 This is used on targets that return BLKmode values in registers.  */
 rtx
-copy_blkmode_to_reg (machine_mode mode, tree src)
+copy_blkmode_to_reg (machine_mode mode_in, tree src)
 {
 int i, n_regs;
 unsigned HOST_WIDE_INT bitpos, xbitpos, padding_correction = 0, bytes;
 unsigned int bitsize;
 rtx *dst_words, dst, x, src_word = NULL_RTX, dst_word = NULL_RTX;
-machine_mode dst_mode;
+/* No current ABI uses variable-sized modes to pass a BLKmnode type.  */
+fixed_size_mode mode = as_a <fixed_size_mode> (mode_in);
+fixed_size_mode dst_mode;
+scalar_int_mode min_mode;
 gcc_assert (TYPE_MODE (TREE_TYPE (src)) == BLKmode);
 x = expand_normal (src);
-bytes = int_size_in_bytes (TREE_TYPE (src));
+bytes = arg_int_size_in_bytes (TREE_TYPE (src));
 if (bytes == 0)
 return NULL_RTX;
 /* If the structure doesn't take up a whole number of words, see
 whether the register value should be padded on the left or on
 					   * BITS_PER_UNIT));
 n_regs = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
 dst_words = XALLOCAVEC (rtx, n_regs);
 bitsize = MIN (TYPE_ALIGN (TREE_TYPE (src)), BITS_PER_WORD);
+min_mode = smallest_int_mode_for_size (bitsize);
 /* Copy the structure BITSIZE bits at a time.  */
 for (bitpos = 0, xbitpos = padding_correction;
 bitpos < bytes * BITS_PER_UNIT;
 bitpos += bitsize, xbitpos += bitsize)
 	  dst_word = gen_reg_rtx (word_mode);
 	  dst_words[xbitpos / BITS_PER_WORD] = dst_word;
 	  /* Clear the destination before we move anything into it.  */
 	  emit_move_insn (dst_word, CONST0_RTX (word_mode));
+	}
+/* Find the largest integer mode that can be used to copy all or as
+	 many bits as possible of the structure if the target supports larger
+	 copies.  There are too many corner cases here w.r.t to alignments on
+	 the read/writes.  So if there is any padding just use single byte
+	 operations.  */
+opt_scalar_int_mode mode_iter;
+if (padding_correction == 0 && !STRICT_ALIGNMENT)
+	{
+	  FOR_EACH_MODE_FROM (mode_iter, min_mode)
+	    {
+	      unsigned int msize = GET_MODE_BITSIZE (mode_iter.require ());
+	      if (msize <= ((bytes * BITS_PER_UNIT) - bitpos)
+		  && msize <= BITS_PER_WORD)
+		bitsize = msize;
+	      else
+		break;
+	    }
 	}
 /* We need a new source operand each time bitpos is on a word
 	 boundary.  */
 if (bitpos % BITS_PER_WORD == 0)
 gcc_assert (method == BLOCK_OP_NORMAL || method == BLOCK_OP_TAILCALL);
 /* If OBJECT is not BLKmode and SIZE is the same size as its mode,
 just move a zero.  Otherwise, do this a piece at a time.  */
+poly_int64 size_val;
 if (mode != BLKmode
-&& CONST_INT_P (size)
+&& poly_int_rtx_p (size, &size_val)
-&& INTVAL (size) == (HOST_WIDE_INT) GET_MODE_SIZE (mode))
+&& known_eq (size_val, GET_MODE_SIZE (mode)))
 {
 rtx zero = CONST0_RTX (mode);
 if (zero != NULL)
 	{
 	  emit_move_insn (object, zero);
 rtx
 emit_move_resolve_push (machine_mode mode, rtx x)
 {
 enum rtx_code code = GET_CODE (XEXP (x, 0));
-HOST_WIDE_INT adjust;
 rtx temp;
-adjust = GET_MODE_SIZE (mode);
+poly_int64 adjust = GET_MODE_SIZE (mode);
 #ifdef PUSH_ROUNDING
 adjust = PUSH_ROUNDING (adjust);
 #endif
 if (code == PRE_DEC || code == POST_DEC)
 adjust = -adjust;
 else if (code == PRE_MODIFY || code == POST_MODIFY)
 {
 rtx expr = XEXP (XEXP (x, 0), 1);
-HOST_WIDE_INT val;
 gcc_assert (GET_CODE (expr) == PLUS || GET_CODE (expr) == MINUS);
-gcc_assert (CONST_INT_P (XEXP (expr, 1)));
+poly_int64 val = rtx_to_poly_int64 (XEXP (expr, 1));
-val = INTVAL (XEXP (expr, 1));
 if (GET_CODE (expr) == MINUS)
 	val = -val;
-gcc_assert (adjust == val || adjust == -val);
+gcc_assert (known_eq (adjust, val) || known_eq (adjust, -val));
 adjust = val;
 }
 /* Do not use anti_adjust_stack, since we don't want to update
 stack_pointer_delta.  */
 {
 scalar_mode submode = GET_MODE_INNER (mode);
 bool imag_first;
 #ifdef PUSH_ROUNDING
-unsigned int submodesize = GET_MODE_SIZE (submode);
+poly_int64 submodesize = GET_MODE_SIZE (submode);
 /* In case we output to the stack, but the size is smaller than the
 machine can push exactly, we need to use move instructions.  */
-if (PUSH_ROUNDING (submodesize) != submodesize)
+if (maybe_ne (PUSH_ROUNDING (submodesize), submodesize))
 {
 x = emit_move_resolve_push (mode, x);
 return emit_move_insn (x, y);
 }
 #endif
 /* For memory to memory moves, optimal behavior can be had with the
 	 existing block move logic.  */
 if (MEM_P (x) && MEM_P (y))
 	{
-	  emit_block_move (x, y, GEN_INT (GET_MODE_SIZE (mode)),
+	  emit_block_move (x, y, gen_int_mode (GET_MODE_SIZE (mode), Pmode),
 			   BLOCK_OP_NO_LIBCALL);
 	  return get_last_insn ();
 	}
 ret = emit_move_via_integer (mode, x, y, true);
 undefined_operand_subword_p (const_rtx op, int i)
 {
 if (GET_CODE (op) != SUBREG)
 return false;
 machine_mode innermostmode = GET_MODE (SUBREG_REG (op));
-HOST_WIDE_INT offset = i * UNITS_PER_WORD + subreg_memory_offset (op);
+poly_int64 offset = i * UNITS_PER_WORD + subreg_memory_offset (op);
-return (offset >= GET_MODE_SIZE (innermostmode)
+return (known_ge (offset, GET_MODE_SIZE (innermostmode))
-	  || offset <= -UNITS_PER_WORD);
+	  || known_le (offset, -UNITS_PER_WORD));
 }
 /* A subroutine of emit_move_insn_1.  Generate a move from Y into X.
 MODE is any multi-word or full-word mode that lacks a move_insn
 pattern.  Note that you will get better code if you define such
 {
 rtx_insn *last_insn = 0;
 rtx_insn *seq;
 rtx inner;
 bool need_clobber;
-int i;
+int i, mode_size;
-gcc_assert (GET_MODE_SIZE (mode) >= UNITS_PER_WORD);
+/* This function can only handle cases where the number of words is
+known at compile time.  */
+mode_size = GET_MODE_SIZE (mode).to_constant ();
+gcc_assert (mode_size >= UNITS_PER_WORD);
 /* If X is a push on the stack, do the push now and replace
 X with a reference to the stack pointer.  */
 if (push_operand (x, mode))
 x = emit_move_resolve_push (mode, x);
 y = replace_equiv_address_nv (y, inner);
 start_sequence ();
 need_clobber = false;
-for (i = 0;
+for (i = 0; i < CEIL (mode_size, UNITS_PER_WORD); i++)
-i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
-i++)
 {
 rtx xpart = operand_subword (x, i, 1, mode);
 rtx ypart;
 /* Do not generate code for a move if it would come entirely
 /* Try using a move pattern for the corresponding integer mode.  This is
 only safe when simplify_subreg can convert MODE constants into integer
 constants.  At present, it can only do this reliably if the value
 fits within a HOST_WIDE_INT.  */
-if (!CONSTANT_P (y) || GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
+if (!CONSTANT_P (y)
+|| known_le (GET_MODE_BITSIZE (mode), HOST_BITS_PER_WIDE_INT))
 {
 rtx_insn *ret = emit_move_via_integer (mode, x, y, lra_in_progress);
 if (ret)
 	{
 EXTRA is the number of bytes of padding to push in addition to SIZE.
 BELOW nonzero means this padding comes at low addresses;
 otherwise, the padding comes at high addresses.  */
 rtx
-push_block (rtx size, int extra, int below)
+push_block (rtx size, poly_int64 extra, int below)
 {
 rtx temp;
 size = convert_modes (Pmode, ptr_mode, size, 1);
 if (CONSTANT_P (size))
 anti_adjust_stack (plus_constant (Pmode, size, extra));
-else if (REG_P (size) && extra == 0)
+else if (REG_P (size) && known_eq (extra, 0))
 anti_adjust_stack (size);
 else
 {
 temp = copy_to_mode_reg (Pmode, size);
-if (extra != 0)
+if (maybe_ne (extra, 0))
 	temp = expand_binop (Pmode, add_optab, temp,
 			     gen_int_mode (extra, Pmode),
 			     temp, 0, OPTAB_LIB_WIDEN);
 anti_adjust_stack (temp);
 }
 if (STACK_GROWS_DOWNWARD)
 {
 temp = virtual_outgoing_args_rtx;
-if (extra != 0 && below)
+if (maybe_ne (extra, 0) && below)
 	temp = plus_constant (Pmode, temp, extra);
 }
 else
 {
-if (CONST_INT_P (size))
+poly_int64 csize;
+if (poly_int_rtx_p (size, &csize))
 	temp = plus_constant (Pmode, virtual_outgoing_args_rtx,
-			      -INTVAL (size) - (below ? 0 : extra));
+			      -csize - (below ? 0 : extra));
-else if (extra != 0 && !below)
+else if (maybe_ne (extra, 0) && !below)
 	temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
 			     negate_rtx (Pmode, plus_constant (Pmode, size,
 							       extra)));
 else
 	temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
 Insns in the sequence that do not modify the SP are ignored,
 except for noreturn calls.
 The return value is the amount of adjustment that can be trivially
 verified, via immediate operand or auto-inc.  If the adjustment
-cannot be trivially extracted, the return value is INT_MIN.  */
+cannot be trivially extracted, the return value is HOST_WIDE_INT_MIN.  */
-HOST_WIDE_INT
+poly_int64
 find_args_size_adjust (rtx_insn *insn)
 {
 rtx dest, set, pat;
 int i;
 if (REG_P (dest) && REGNO (dest) == STACK_POINTER_REGNUM)
 {
 /* Look for a trivial adjustment, otherwise assume nothing.  */
 /* Note that the SPU restore_stack_block pattern refers to
 	 the stack pointer in V4SImode.  Consider that non-trivial.  */
+poly_int64 offset;
 if (SCALAR_INT_MODE_P (GET_MODE (dest))
-	  && GET_CODE (SET_SRC (set)) == PLUS
+	  && strip_offset (SET_SRC (set), &offset) == stack_pointer_rtx)
-	  && XEXP (SET_SRC (set), 0) == stack_pointer_rtx
+	return offset;
-	  && CONST_INT_P (XEXP (SET_SRC (set), 1)))
-	return INTVAL (XEXP (SET_SRC (set), 1));
 /* ??? Reload can generate no-op moves, which will be cleaned
 	 up later.  Recognize it and continue searching.  */
 else if (rtx_equal_p (dest, SET_SRC (set)))
 	return 0;
 else
 	case PRE_MODIFY:
 	case POST_MODIFY:
 	  addr = XEXP (addr, 1);
 	  gcc_assert (GET_CODE (addr) == PLUS);
 	  gcc_assert (XEXP (addr, 0) == stack_pointer_rtx);
-	  gcc_assert (CONST_INT_P (XEXP (addr, 1)));
+	  return rtx_to_poly_int64 (XEXP (addr, 1));
-	  return INTVAL (XEXP (addr, 1));
 	default:
 	  gcc_unreachable ();
 	}
 }
 }
-int
+poly_int64
-fixup_args_size_notes (rtx_insn *prev, rtx_insn *last, int end_args_size)
+fixup_args_size_notes (rtx_insn *prev, rtx_insn *last,
-{
+		       poly_int64 end_args_size)
-int args_size = end_args_size;
+{
+poly_int64 args_size = end_args_size;
 bool saw_unknown = false;
 rtx_insn *insn;
 for (insn = last; insn != prev; insn = PREV_INSN (insn))
 {
-HOST_WIDE_INT this_delta;
 if (!NONDEBUG_INSN_P (insn))
 	continue;
-this_delta = find_args_size_adjust (insn);
+/* We might have existing REG_ARGS_SIZE notes, e.g. when pushing
-if (this_delta == 0)
+	 a call argument containing a TLS address that itself requires
+	 a call to __tls_get_addr.  The handling of stack_pointer_delta
+	 in emit_single_push_insn is supposed to ensure that any such
+	 notes are already correct.  */
+rtx note = find_reg_note (insn, REG_ARGS_SIZE, NULL_RTX);
+gcc_assert (!note || known_eq (args_size, get_args_size (note)));
+poly_int64 this_delta = find_args_size_adjust (insn);
+if (known_eq (this_delta, 0))
 	{
 	  if (!CALL_P (insn)
 	      || ACCUMULATE_OUTGOING_ARGS
 	      || find_reg_note (insn, REG_NORETURN, NULL_RTX) == NULL_RTX)
 	    continue;
 	}
 gcc_assert (!saw_unknown);
-if (this_delta == HOST_WIDE_INT_MIN)
+if (known_eq (this_delta, HOST_WIDE_INT_MIN))
 	saw_unknown = true;
-add_reg_note (insn, REG_ARGS_SIZE, GEN_INT (args_size));
+if (!note)
+	add_args_size_note (insn, args_size);
 if (STACK_GROWS_DOWNWARD)
-	this_delta = -(unsigned HOST_WIDE_INT) this_delta;
+	this_delta = -poly_uint64 (this_delta);
-args_size -= this_delta;
+if (saw_unknown)
-}
+	args_size = HOST_WIDE_INT_MIN;
+else
-return saw_unknown ? INT_MIN : args_size;
+	args_size -= this_delta;
+}
+return args_size;
 }
 #ifdef PUSH_ROUNDING
 /* Emit single push insn.  */
 static void
 emit_single_push_insn_1 (machine_mode mode, rtx x, tree type)
 {
 rtx dest_addr;
-unsigned rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
+poly_int64 rounded_size = PUSH_ROUNDING (GET_MODE_SIZE (mode));
 rtx dest;
 enum insn_code icode;
-stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
 /* If there is push pattern, use it.  Otherwise try old way of throwing
 MEM representing push operation to move expander.  */
 icode = optab_handler (push_optab, mode);
 if (icode != CODE_FOR_nothing)
 {
 create_input_operand (&ops[0], x, mode);
 if (maybe_expand_insn (icode, 1, ops))
 	return;
 }
-if (GET_MODE_SIZE (mode) == rounded_size)
+if (known_eq (GET_MODE_SIZE (mode), rounded_size))
 dest_addr = gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
 /* If we are to pad downward, adjust the stack pointer first and
 then store X into the stack location using an offset.  This is
 because emit_move_insn does not know how to pad; it does not have
 access to type.  */
 else if (targetm.calls.function_arg_padding (mode, type) == PAD_DOWNWARD)
 {
-unsigned padding_size = rounded_size - GET_MODE_SIZE (mode);
-HOST_WIDE_INT offset;
 emit_move_insn (stack_pointer_rtx,
 		      expand_binop (Pmode,
 				    STACK_GROWS_DOWNWARD ? sub_optab
 				    : add_optab,
 				    stack_pointer_rtx,
 				    gen_int_mode (rounded_size, Pmode),
 				    NULL_RTX, 0, OPTAB_LIB_WIDEN));
-offset = (HOST_WIDE_INT) padding_size;
+poly_int64 offset = rounded_size - GET_MODE_SIZE (mode);
 if (STACK_GROWS_DOWNWARD && STACK_PUSH_CODE == POST_DEC)
 	/* We have already decremented the stack pointer, so get the
 	   previous value.  */
-	offset += (HOST_WIDE_INT) rounded_size;
+	offset += rounded_size;
 if (!STACK_GROWS_DOWNWARD && STACK_PUSH_CODE == POST_INC)
 	/* We have already incremented the stack pointer, so get the
 	   previous value.  */
-	offset -= (HOST_WIDE_INT) rounded_size;
+	offset -= rounded_size;
-dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
+dest_addr = plus_constant (Pmode, stack_pointer_rtx, offset);
-				gen_int_mode (offset, Pmode));
 }
 else
 {
 if (STACK_GROWS_DOWNWARD)
 	/* ??? This seems wrong if STACK_PUSH_CODE == POST_DEC.  */
-	dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
+	dest_addr = plus_constant (Pmode, stack_pointer_rtx, -rounded_size);
-				  gen_int_mode (-(HOST_WIDE_INT) rounded_size,
-						Pmode));
 else
 	/* ??? This seems wrong if STACK_PUSH_CODE == POST_INC.  */
-	dest_addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
+	dest_addr = plus_constant (Pmode, stack_pointer_rtx, rounded_size);
-				  gen_int_mode (rounded_size, Pmode));
 dest_addr = gen_rtx_PRE_MODIFY (Pmode, stack_pointer_rtx, dest_addr);
 }
 dest = gen_rtx_MEM (mode, dest_addr);
 /* Emit and annotate a single push insn.  */
 static void
 emit_single_push_insn (machine_mode mode, rtx x, tree type)
 {
-int delta, old_delta = stack_pointer_delta;
+poly_int64 delta, old_delta = stack_pointer_delta;
 rtx_insn *prev = get_last_insn ();
 rtx_insn *last;
 emit_single_push_insn_1 (mode, x, type);
+/* Adjust stack_pointer_delta to describe the situation after the push
+we just performed.  Note that we must do this after the push rather
+than before the push in case calculating X needs pushes and pops of
+its own (e.g. if calling __tls_get_addr).  The REG_ARGS_SIZE notes
+for such pushes and pops must not include the effect of the future
+push of X.  */
+stack_pointer_delta += PUSH_ROUNDING (GET_MODE_SIZE (mode));
 last = get_last_insn ();
 /* Notice the common case where we emitted exactly one insn.  */
 if (PREV_INSN (last) == prev)
 {
-add_reg_note (last, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
+add_args_size_note (last, stack_pointer_delta);
 return;
 }
 delta = fixup_args_size_notes (prev, last, stack_pointer_delta);
-gcc_assert (delta == INT_MIN || delta == old_delta);
+gcc_assert (known_eq (delta, HOST_WIDE_INT_MIN)
+	      || known_eq (delta, old_delta));
 }
 #endif
 /* If reading SIZE bytes from X will end up reading from
 Y return the number of bytes that overlap.  Return -1
 for arguments passed in registers.  If nonzero, it will be the number
 of bytes required.  */
 bool
 emit_push_insn (rtx x, machine_mode mode, tree type, rtx size,
-		unsigned int align, int partial, rtx reg, int extra,
+		unsigned int align, int partial, rtx reg, poly_int64 extra,
 		rtx args_addr, rtx args_so_far, int reg_parm_stack_space,
 		rtx alignment_pad, bool sibcall_p)
 {
 rtx xinner;
 pad_direction stack_direction
 if (mode != BLKmode)
 	{
 	  /* A value is to be stored in an insufficiently aligned
 	     stack slot; copy via a suitably aligned slot if
 	     necessary.  */
-	  size = GEN_INT (GET_MODE_SIZE (mode));
+	  size = gen_int_mode (GET_MODE_SIZE (mode), Pmode);
 	  if (!MEM_P (xinner))
 	    {
 	      temp = assign_temp (type, 1, 1);
 	      emit_move_insn (temp, xinner);
 	      xinner = temp;
 	  /* Here we avoid the case of a structure whose weak alignment
 	     forces many pushes of a small amount of data,
 	     and such small pushes do rounding that causes trouble.  */
 	  && ((!targetm.slow_unaligned_access (word_mode, align))
 	      || align >= BIGGEST_ALIGNMENT
-	      || (PUSH_ROUNDING (align / BITS_PER_UNIT)
+	      || known_eq (PUSH_ROUNDING (align / BITS_PER_UNIT),
-		  == (align / BITS_PER_UNIT)))
+			   align / BITS_PER_UNIT))
-	  && (HOST_WIDE_INT) PUSH_ROUNDING (INTVAL (size)) == INTVAL (size))
+	  && known_eq (PUSH_ROUNDING (INTVAL (size)), INTVAL (size)))
 	{
 	  /* Push padding now if padding above and stack grows down,
 	     or if padding below and stack grows up.
 	     But if space already allocated, this has already been done.  */
-	  if (extra && args_addr == 0
+	  if (maybe_ne (extra, 0)
-	      && where_pad != PAD_NONE && where_pad != stack_direction)
+	      && args_addr == 0
-	    anti_adjust_stack (GEN_INT (extra));
+	      && where_pad != PAD_NONE
+	      && where_pad != stack_direction)
+	    anti_adjust_stack (gen_int_mode (extra, Pmode));
 	  move_by_pieces (NULL, xinner, INTVAL (size) - used, align, 0);
 	}
 else
 #endif /* PUSH_ROUNDING  */
 	    }
 	  /* Get the address of the stack space.
 	     In this case, we do not deal with EXTRA separately.
 	     A single stack adjust will do.  */
+	  poly_int64 offset;
 	  if (! args_addr)
 	    {
 	      temp = push_block (size, extra, where_pad == PAD_DOWNWARD);
 	      extra = 0;
 	    }
-	  else if (CONST_INT_P (args_so_far))
+	  else if (poly_int_rtx_p (args_so_far, &offset))
 	    temp = memory_address (BLKmode,
 				   plus_constant (Pmode, args_addr,
-						  skip + INTVAL (args_so_far)));
+						  skip + offset));
 	  else
 	    temp = memory_address (BLKmode,
 				   plus_constant (Pmode,
 						  gen_rtx_PLUS (Pmode,
 								args_addr,
 	  emit_block_move (target, xinner, size, BLOCK_OP_CALL_PARM);
 	}
 }
 else if (partial > 0)
 {
-/* Scalar partly in registers.  */
+/* Scalar partly in registers.  This case is only supported
+	 for fixed-wdth modes.  */
-int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
+int size = GET_MODE_SIZE (mode).to_constant ();
+size /= UNITS_PER_WORD;
 int i;
 int not_stack;
 /* # bytes of start of argument
 	 that we must make space for but need not store.  */
 int offset = partial % (PARM_BOUNDARY / BITS_PER_UNIT);
 int skip;
 /* Push padding now if padding above and stack grows down,
 	 or if padding below and stack grows up.
 	 But if space already allocated, this has already been done.  */
-if (extra && args_addr == 0
+if (maybe_ne (extra, 0)
-	  && where_pad != PAD_NONE && where_pad != stack_direction)
+	  && args_addr == 0
-	anti_adjust_stack (GEN_INT (extra));
+	  && where_pad != PAD_NONE
+	  && where_pad != stack_direction)
+	anti_adjust_stack (gen_int_mode (extra, Pmode));
 /* If we make space by pushing it, we might as well push
 	 the real data.  Otherwise, we can leave OFFSET nonzero
 	 and leave the space uninitialized.  */
 if (args_addr == 0)
 rtx dest;
 /* Push padding now if padding above and stack grows down,
 	 or if padding below and stack grows up.
 	 But if space already allocated, this has already been done.  */
-if (extra && args_addr == 0
+if (maybe_ne (extra, 0)
-	  && where_pad != PAD_NONE && where_pad != stack_direction)
+	  && args_addr == 0
-	anti_adjust_stack (GEN_INT (extra));
+	  && where_pad != PAD_NONE
+	  && where_pad != stack_direction)
+	anti_adjust_stack (gen_int_mode (extra, Pmode));
 #ifdef PUSH_ROUNDING
 if (args_addr == 0 && PUSH_ARGS)
 	emit_single_push_insn (mode, x, type);
 else
 			    tmp_regs[i]);
 	}
 }
-if (extra && args_addr == 0 && where_pad == stack_direction)
+if (maybe_ne (extra, 0) && args_addr == 0 && where_pad == stack_direction)
-anti_adjust_stack (GEN_INT (extra));
+anti_adjust_stack (gen_int_mode (extra, Pmode));
 if (alignment_pad && args_addr == 0)
 anti_adjust_stack (alignment_pad);
 return true;
 /* A subroutine of expand_assignment.  Optimize FIELD op= VAL, where
 FIELD is a bitfield.  Returns true if the optimization was successful,
 and there's nothing else to do.  */
 static bool
-optimize_bitfield_assignment_op (unsigned HOST_WIDE_INT bitsize,
+optimize_bitfield_assignment_op (poly_uint64 pbitsize,
-				 unsigned HOST_WIDE_INT bitpos,
+				 poly_uint64 pbitpos,
-				 unsigned HOST_WIDE_INT bitregion_start,
+				 poly_uint64 pbitregion_start,
-				 unsigned HOST_WIDE_INT bitregion_end,
+				 poly_uint64 pbitregion_end,
 				 machine_mode mode1, rtx str_rtx,
 				 tree to, tree src, bool reverse)
 {
+/* str_mode is not guaranteed to be a scalar type.  */
 machine_mode str_mode = GET_MODE (str_rtx);
-unsigned int str_bitsize = GET_MODE_BITSIZE (str_mode);
+unsigned int str_bitsize;
 tree op0, op1;
 rtx value, result;
 optab binop;
 gimple *srcstmt;
 enum tree_code code;
+unsigned HOST_WIDE_INT bitsize, bitpos, bitregion_start, bitregion_end;
 if (mode1 != VOIDmode
+|| !pbitsize.is_constant (&bitsize)
+|| !pbitpos.is_constant (&bitpos)
+|| !pbitregion_start.is_constant (&bitregion_start)
+|| !pbitregion_end.is_constant (&bitregion_end)
 || bitsize >= BITS_PER_WORD
+|| !GET_MODE_BITSIZE (str_mode).is_constant (&str_bitsize)
 || str_bitsize > BITS_PER_WORD
 || TREE_SIDE_EFFECTS (to)
 || TREE_THIS_VOLATILE (to))
 return false;
 offset1 = (offset1 - bitpos) / BITS_PER_UNIT;
 str_rtx = adjust_address (str_rtx, str_mode, offset1);
 }
 else if (!REG_P (str_rtx) && GET_CODE (str_rtx) != SUBREG)
 return false;
-else
-gcc_assert (!reverse);
 /* If the bit field covers the whole REG/MEM, store_field
 will likely generate better code.  */
 if (bitsize >= str_bitsize)
 return false;
 If the access does not need to be restricted, 0 is returned in both
 *BITSTART and *BITEND.  */
 void
-get_bit_range (unsigned HOST_WIDE_INT *bitstart,
+get_bit_range (poly_uint64_pod *bitstart, poly_uint64_pod *bitend, tree exp,
-	       unsigned HOST_WIDE_INT *bitend,
+	       poly_int64_pod *bitpos, tree *offset)
-	       tree exp,
+{
-	       HOST_WIDE_INT *bitpos,
+poly_int64 bitoffset;
-	       tree *offset)
-{
-HOST_WIDE_INT bitoffset;
 tree field, repr;
 gcc_assert (TREE_CODE (exp) == COMPONENT_REF);
 field = TREE_OPERAND (exp, 1);
 part of a larger bit field, then the representative does not serve any
 useful purpose.  This can occur in Ada.  */
 if (handled_component_p (TREE_OPERAND (exp, 0)))
 {
 machine_mode rmode;
-HOST_WIDE_INT rbitsize, rbitpos;
+poly_int64 rbitsize, rbitpos;
 tree roffset;
 int unsignedp, reversep, volatilep = 0;
 get_inner_reference (TREE_OPERAND (exp, 0), &rbitsize, &rbitpos,
 			   &roffset, &rmode, &unsignedp, &reversep,
 			   &volatilep);
-if ((rbitpos % BITS_PER_UNIT) != 0)
+if (!multiple_p (rbitpos, BITS_PER_UNIT))
 	{
 	  *bitstart = *bitend = 0;
 	  return;
 	}
 }
 /* Compute the adjustment to bitpos from the offset of the field
 relative to the representative.  DECL_FIELD_OFFSET of field and
 repr are the same by construction if they are not constants,
 see finish_bitfield_layout.  */
-if (tree_fits_uhwi_p (DECL_FIELD_OFFSET (field))
+poly_uint64 field_offset, repr_offset;
-&& tree_fits_uhwi_p (DECL_FIELD_OFFSET (repr)))
+if (poly_int_tree_p (DECL_FIELD_OFFSET (field), &field_offset)
-bitoffset = (tree_to_uhwi (DECL_FIELD_OFFSET (field))
+&& poly_int_tree_p (DECL_FIELD_OFFSET (repr), &repr_offset))
-		 - tree_to_uhwi (DECL_FIELD_OFFSET (repr))) * BITS_PER_UNIT;
+bitoffset = (field_offset - repr_offset) * BITS_PER_UNIT;
 else
 bitoffset = 0;
 bitoffset += (tree_to_uhwi (DECL_FIELD_BIT_OFFSET (field))
 		- tree_to_uhwi (DECL_FIELD_BIT_OFFSET (repr)));
 /* If the adjustment is larger than bitpos, we would have a negative bit
 position for the lower bound and this may wreak havoc later.  Adjust
 offset and bitpos to make the lower bound non-negative in that case.  */
-if (bitoffset > *bitpos)
+if (maybe_gt (bitoffset, *bitpos))
 {
-HOST_WIDE_INT adjust = bitoffset - *bitpos;
+poly_int64 adjust_bits = upper_bound (bitoffset, *bitpos) - *bitpos;
-gcc_assert ((adjust % BITS_PER_UNIT) == 0);
+poly_int64 adjust_bytes = exact_div (adjust_bits, BITS_PER_UNIT);
-*bitpos += adjust;
+*bitpos += adjust_bits;
 if (*offset == NULL_TREE)
-	*offset = size_int (-adjust / BITS_PER_UNIT);
+	*offset = size_int (-adjust_bytes);
 else
-	*offset
+	*offset = size_binop (MINUS_EXPR, *offset, size_int (adjust_bytes));
-	  = size_binop (MINUS_EXPR, *offset, size_int (adjust / BITS_PER_UNIT));
 *bitstart = 0;
 }
 else
 *bitstart = *bitpos - bitoffset;
-*bitend = *bitstart + tree_to_uhwi (DECL_SIZE (repr)) - 1;
+*bitend = *bitstart + tree_to_poly_uint64 (DECL_SIZE (repr)) - 1;
 }
 /* Returns true if ADDR is an ADDR_EXPR of a DECL that does not reside
 in memory and has non-BLKmode.  DECL_RTL must not be a MEM; if
 DECL_RTL was not set yet, return NORTL.  */
 	  && (REF_REVERSE_STORAGE_ORDER (to)
 	      || mem_ref_refers_to_non_mem_p (to)))
 || TREE_CODE (TREE_TYPE (to)) == ARRAY_TYPE)
 {
 machine_mode mode1;
-HOST_WIDE_INT bitsize, bitpos;
+poly_int64 bitsize, bitpos;
-unsigned HOST_WIDE_INT bitregion_start = 0;
+poly_uint64 bitregion_start = 0;
-unsigned HOST_WIDE_INT bitregion_end = 0;
+poly_uint64 bitregion_end = 0;
 tree offset;
 int unsignedp, reversep, volatilep = 0;
 tree tem;
 push_temp_slots ();
 tem = get_inner_reference (to, &bitsize, &bitpos, &offset, &mode1,
 				 &unsignedp, &reversep, &volatilep);
 /* Make sure bitpos is not negative, it can wreak havoc later.  */
-if (bitpos < 0)
+if (maybe_lt (bitpos, 0))
 	{
 	  gcc_assert (offset == NULL_TREE);
-	  offset = size_int (bitpos >> LOG2_BITS_PER_UNIT);
+	  offset = size_int (bits_to_bytes_round_down (bitpos));
-	  bitpos &= BITS_PER_UNIT - 1;
+	  bitpos = num_trailing_bits (bitpos);
 	}
 if (TREE_CODE (to) == COMPONENT_REF
 	  && DECL_BIT_FIELD_TYPE (TREE_OPERAND (to, 1)))
 	get_bit_range (&bitregion_start, &bitregion_end, to, &bitpos, &offset);
 /* The C++ memory model naturally applies to byte-aligned fields.
 	 However, if we do not have a DECL_BIT_FIELD_TYPE but BITPOS or
 	 BITSIZE are not byte-aligned, there is no need to limit the range
 	 we can access.  This can occur with packed structures in Ada.  */
-else if (bitsize > 0
+else if (maybe_gt (bitsize, 0)
-	       && bitsize % BITS_PER_UNIT == 0
+	       && multiple_p (bitsize, BITS_PER_UNIT)
-	       && bitpos % BITS_PER_UNIT == 0)
+	       && multiple_p (bitpos, BITS_PER_UNIT))
 	{
 	  bitregion_start = bitpos;
 	  bitregion_end = bitpos + bitsize - 1;
 	}
 	     r124:DI=r123:DI+0x10
 	     [r124:DI+0x8]=r121:DI
 	     This is only done for aligned data values, as these can
 	     be expected to result in single move instructions.  */
+	  poly_int64 bytepos;
 	  if (mode1 != VOIDmode
-	      && bitpos != 0
+	      && maybe_ne (bitpos, 0)
-	      && bitsize > 0
+	      && maybe_gt (bitsize, 0)
-	      && (bitpos % bitsize) == 0
+	      && multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
-	      && (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
+	      && multiple_p (bitpos, bitsize)
+	      && multiple_p (bitsize, GET_MODE_ALIGNMENT (mode1))
 	      && MEM_ALIGN (to_rtx) >= GET_MODE_ALIGNMENT (mode1))
 	    {
-	      to_rtx = adjust_address (to_rtx, mode1, bitpos / BITS_PER_UNIT);
+	      to_rtx = adjust_address (to_rtx, mode1, bytepos);
 	      bitregion_start = 0;
-	      if (bitregion_end >= (unsigned HOST_WIDE_INT) bitpos)
+	      if (known_ge (bitregion_end, poly_uint64 (bitpos)))
 		bitregion_end -= bitpos;
 	      bitpos = 0;
 	    }
 	  to_rtx = offset_address (to_rtx, offset_rtx,
 /* No action is needed if the target is not a memory and the field
 	 lies completely outside that target.  This can occur if the source
 	 code contains an out-of-bounds access to a small array.  */
 if (!MEM_P (to_rtx)
 	  && GET_MODE (to_rtx) != BLKmode
-	  && (unsigned HOST_WIDE_INT) bitpos
+	  && known_ge (bitpos, GET_MODE_PRECISION (GET_MODE (to_rtx))))
-	     >= GET_MODE_PRECISION (GET_MODE (to_rtx)))
 	{
 	  expand_normal (from);
 	  result = NULL;
 	}
 /* Handle expand_expr of a complex value returning a CONCAT.  */
 else if (GET_CODE (to_rtx) == CONCAT)
 	{
-	  unsigned short mode_bitsize = GET_MODE_BITSIZE (GET_MODE (to_rtx));
+	  machine_mode to_mode = GET_MODE (to_rtx);
-	  if (COMPLEX_MODE_P (TYPE_MODE (TREE_TYPE (from)))
+	  gcc_checking_assert (COMPLEX_MODE_P (to_mode));
-	      && bitpos == 0
+	  poly_int64 mode_bitsize = GET_MODE_BITSIZE (to_mode);
-	      && bitsize == mode_bitsize)
+	  unsigned short inner_bitsize = GET_MODE_UNIT_BITSIZE (to_mode);
+	  if (TYPE_MODE (TREE_TYPE (from)) == to_mode
+	      && known_eq (bitpos, 0)
+	      && known_eq (bitsize, mode_bitsize))
 	    result = store_expr (from, to_rtx, false, nontemporal, reversep);
-	  else if (bitsize == mode_bitsize / 2
+	  else if (TYPE_MODE (TREE_TYPE (from)) == GET_MODE_INNER (to_mode)
-		   && (bitpos == 0 || bitpos == mode_bitsize / 2))
+		   && known_eq (bitsize, inner_bitsize)
-	    result = store_expr (from, XEXP (to_rtx, bitpos != 0), false,
+		   && (known_eq (bitpos, 0)
-				 nontemporal, reversep);
+		       || known_eq (bitpos, inner_bitsize)))
-	  else if (bitpos + bitsize <= mode_bitsize / 2)
+	    result = store_expr (from, XEXP (to_rtx, maybe_ne (bitpos, 0)),
+				 false, nontemporal, reversep);
+	  else if (known_le (bitpos + bitsize, inner_bitsize))
 	    result = store_field (XEXP (to_rtx, 0), bitsize, bitpos,
 				  bitregion_start, bitregion_end,
 				  mode1, from, get_alias_set (to),
 				  nontemporal, reversep);
-	  else if (bitpos >= mode_bitsize / 2)
+	  else if (known_ge (bitpos, inner_bitsize))
 	    result = store_field (XEXP (to_rtx, 1), bitsize,
-				  bitpos - mode_bitsize / 2,
+				  bitpos - inner_bitsize,
 				  bitregion_start, bitregion_end,
 				  mode1, from, get_alias_set (to),
 				  nontemporal, reversep);
-	  else if (bitpos == 0 && bitsize == mode_bitsize)
+	  else if (known_eq (bitpos, 0) && known_eq (bitsize, mode_bitsize))
 	    {
-	      rtx from_rtx;
 	      result = expand_normal (from);
-	      from_rtx = simplify_gen_subreg (GET_MODE (to_rtx), result,
+	      if (GET_CODE (result) == CONCAT)
-					      TYPE_MODE (TREE_TYPE (from)), 0);
+		{
-	      emit_move_insn (XEXP (to_rtx, 0),
+		  to_mode = GET_MODE_INNER (to_mode);
-			      read_complex_part (from_rtx, false));
+		  machine_mode from_mode = GET_MODE_INNER (GET_MODE (result));
-	      emit_move_insn (XEXP (to_rtx, 1),
+		  rtx from_real
-			      read_complex_part (from_rtx, true));
+		    = simplify_gen_subreg (to_mode, XEXP (result, 0),
+					   from_mode, 0);
+		  rtx from_imag
+		    = simplify_gen_subreg (to_mode, XEXP (result, 1),
+					   from_mode, 0);
+		  if (!from_real || !from_imag)
+		    goto concat_store_slow;
+		  emit_move_insn (XEXP (to_rtx, 0), from_real);
+		  emit_move_insn (XEXP (to_rtx, 1), from_imag);
+		}
+	      else
+		{
+		  rtx from_rtx
+		    = simplify_gen_subreg (to_mode, result,
+					   TYPE_MODE (TREE_TYPE (from)), 0);
+		  if (from_rtx)
+		    {
+		      emit_move_insn (XEXP (to_rtx, 0),
+				      read_complex_part (from_rtx, false));
+		      emit_move_insn (XEXP (to_rtx, 1),
+				      read_complex_part (from_rtx, true));
+		    }
+		  else
+		    {
+		      machine_mode to_mode
+			= GET_MODE_INNER (GET_MODE (to_rtx));
+		      rtx from_real
+			= simplify_gen_subreg (to_mode, result,
+					       TYPE_MODE (TREE_TYPE (from)),
+					       0);
+		      rtx from_imag
+			= simplify_gen_subreg (to_mode, result,
+					       TYPE_MODE (TREE_TYPE (from)),
+					       GET_MODE_SIZE (to_mode));
+		      if (!from_real || !from_imag)
+			goto concat_store_slow;
+		      emit_move_insn (XEXP (to_rtx, 0), from_real);
+		      emit_move_insn (XEXP (to_rtx, 1), from_imag);
+		    }
+		}
 	    }
 	  else
 	    {
-	      rtx temp = assign_stack_temp (GET_MODE (to_rtx),
+	    concat_store_slow:;
+	      rtx temp = assign_stack_temp (to_mode,
 					    GET_MODE_SIZE (GET_MODE (to_rtx)));
 	      write_complex_part (temp, XEXP (to_rtx, 0), false);
 	      write_complex_part (temp, XEXP (to_rtx, 1), true);
 	      result = store_field (temp, bitsize, bitpos,
 				    bitregion_start, bitregion_end,
 	      set_mem_attributes_minus_bitpos (to_rtx, to, 0, bitpos);
 	      if (volatilep)
 		MEM_VOLATILE_P (to_rtx) = 1;
 	    }
+	  gcc_checking_assert (known_ge (bitpos, 0));
 	  if (optimize_bitfield_assignment_op (bitsize, bitpos,
 					       bitregion_start, bitregion_end,
 					       mode1, to_rtx, to, from,
 					       reversep))
 	    result = NULL;
 	      || TREE_CODE (to) == RESULT_DECL)
 	     && REG_P (DECL_RTL (to)))
 	    || TREE_CODE (to) == SSA_NAME))
 {
 rtx value;
-rtx bounds;
 push_temp_slots ();
 value = expand_normal (from);
-/* Split value and bounds to store them separately.  */
-chkp_split_slot (value, &value, &bounds);
 if (to_rtx == 0)
 	to_rtx = expand_expr (to, NULL_RTX, VOIDmode, EXPAND_WRITE);
 /* Handle calls that return values in multiple non-contiguous locations.
 	    value = convert_memory_address_addr_space
 	      (as_a <scalar_int_mode> (GET_MODE (to_rtx)), value,
 	       TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (to))));
 	  emit_move_insn (to_rtx, value);
-	}
-/* Store bounds if required.  */
-if (bounds
-	  && (BOUNDED_P (to) || chkp_type_has_pointer (TREE_TYPE (to))))
-	{
-	  gcc_assert (MEM_P (to_rtx));
-	  chkp_emit_bounds_store (bounds, value, to_rtx);
 	}
 preserve_temp_slots (to_rtx);
 pop_temp_slots ();
 return;
 }
 /* Compute FROM and store the value in the rtx we got.  */
 push_temp_slots ();
-result = store_expr_with_bounds (from, to_rtx, 0, nontemporal, false, to);
+result = store_expr (from, to_rtx, 0, nontemporal, false);
 preserve_temp_slots (result);
 pop_temp_slots ();
 return;
 }
 If CALL_PARAM_P is nonzero, this is a store into a call param on the
 stack, and block moves may need to be treated specially.
 If NONTEMPORAL is true, try using a nontemporal store instruction.
-If REVERSE is true, the store is to be done in reverse order.
+If REVERSE is true, the store is to be done in reverse order.  */
-If BTARGET is not NULL then computed bounds of EXP are
-associated with BTARGET.  */
 rtx
-store_expr_with_bounds (tree exp, rtx target, int call_param_p,
+store_expr (tree exp, rtx target, int call_param_p,
-			bool nontemporal, bool reverse, tree btarget)
+			bool nontemporal, bool reverse)
 {
 rtx temp;
 rtx alt_rtl = NULL_RTX;
 location_t loc = curr_insn_location ();
 {
 /* Perform first part of compound expression, then assign from second
 	 part.  */
 expand_expr (TREE_OPERAND (exp, 0), const0_rtx, VOIDmode,
 		   call_param_p ? EXPAND_STACK_PARM : EXPAND_NORMAL);
-return store_expr_with_bounds (TREE_OPERAND (exp, 1), target,
+return store_expr (TREE_OPERAND (exp, 1), target,
-				     call_param_p, nontemporal, reverse,
+				     call_param_p, nontemporal, reverse);
-				     btarget);
 }
 else if (TREE_CODE (exp) == COND_EXPR && GET_MODE (target) == BLKmode)
 {
 /* For conditional expression, get safe form of the target.  Then
 	 test the condition, doing the appropriate assignment on either
 do_pending_stack_adjust ();
 NO_DEFER_POP;
 jumpifnot (TREE_OPERAND (exp, 0), lab1,
 		 profile_probability::uninitialized ());
-store_expr_with_bounds (TREE_OPERAND (exp, 1), target, call_param_p,
+store_expr (TREE_OPERAND (exp, 1), target, call_param_p,
-			      nontemporal, reverse, btarget);
+		  nontemporal, reverse);
 emit_jump_insn (targetm.gen_jump (lab2));
 emit_barrier ();
 emit_label (lab1);
-store_expr_with_bounds (TREE_OPERAND (exp, 2), target, call_param_p,
+store_expr (TREE_OPERAND (exp, 2), target, call_param_p,
-			      nontemporal, reverse, btarget);
+		  nontemporal, reverse);
 emit_label (lab2);
 OK_DEFER_POP;
 return NULL_RTX;
 }
 	}
 temp = expand_expr (exp, inner_target, VOIDmode,
 			  call_param_p ? EXPAND_STACK_PARM : EXPAND_NORMAL);
-/* Handle bounds returned by call.  */
-if (TREE_CODE (exp) == CALL_EXPR)
-	{
-	  rtx bounds;
-	  chkp_split_slot (temp, &temp, &bounds);
-	  if (bounds && btarget)
-	    {
-	      gcc_assert (TREE_CODE (btarget) == SSA_NAME);
-	      rtx tmp = targetm.calls.load_returned_bounds (bounds);
-	      chkp_set_rtl_bounds (btarget, tmp);
-	    }
-	}
 /* If TEMP is a VOIDmode constant, use convert_modes to make
 	 sure that we properly convert it.  */
 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode)
 	{
 tmp_target = nontemporal || reverse ? NULL_RTX : target;
 temp = expand_expr_real (exp, tmp_target, GET_MODE (target),
 			       (call_param_p
 				? EXPAND_STACK_PARM : EXPAND_NORMAL),
 			       &alt_rtl, false);
-/* Handle bounds returned by call.  */
-if (TREE_CODE (exp) == CALL_EXPR)
-	{
-	  rtx bounds;
-	  chkp_split_slot (temp, &temp, &bounds);
-	  if (bounds && btarget)
-	    {
-	      gcc_assert (TREE_CODE (btarget) == SSA_NAME);
-	      rtx tmp = targetm.calls.load_returned_bounds (bounds);
-	      chkp_set_rtl_bounds (btarget, tmp);
-	    }
-	}
 }
 /* If TEMP is a VOIDmode constant and the mode of the type of EXP is not
 the same as that of TARGET, adjust the constant.  This is needed, for
 example, in case it is a CONST_DOUBLE or CONST_WIDE_INT and we want
 only a word-sized value.  */
 if (CONSTANT_P (temp) && GET_MODE (temp) == VOIDmode
 && TREE_CODE (exp) != ERROR_MARK
 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
-temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
+{
-			  temp, TYPE_UNSIGNED (TREE_TYPE (exp)));
+if (GET_MODE_CLASS (GET_MODE (target))
+	  != GET_MODE_CLASS (TYPE_MODE (TREE_TYPE (exp)))
+	  && known_eq (GET_MODE_BITSIZE (GET_MODE (target)),
+		       GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (exp)))))
+	{
+	  rtx t = simplify_gen_subreg (GET_MODE (target), temp,
+				       TYPE_MODE (TREE_TYPE (exp)), 0);
+	  if (t)
+	    temp = t;
+	}
+if (GET_MODE (temp) == VOIDmode)
+	temp = convert_modes (GET_MODE (target), TYPE_MODE (TREE_TYPE (exp)),
+			      temp, TYPE_UNSIGNED (TREE_TYPE (exp)));
+}
 /* If value was not generated in the target, store it there.
 Convert the value to TARGET's type first if necessary and emit the
 pending incrementations that have been queued when expanding EXP.
 Note that we cannot emit the whole queue blindly because this will
 			       (call_param_p
 				? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
 	      /* Figure out how much is left in TARGET that we have to clear.
 		 Do all calculations in pointer_mode.  */
-	      if (CONST_INT_P (copy_size_rtx))
+	      poly_int64 const_copy_size;
+	      if (poly_int_rtx_p (copy_size_rtx, &const_copy_size))
 		{
-		  size = plus_constant (address_mode, size,
+		  size = plus_constant (address_mode, size, -const_copy_size);
-					-INTVAL (copy_size_rtx));
+		  target = adjust_address (target, BLKmode, const_copy_size);
-		  target = adjust_address (target, BLKmode,
-					   INTVAL (copy_size_rtx));
 		}
 	      else
 		{
 		  size = expand_binop (TYPE_MODE (sizetype), sub_optab, size,
 				       copy_size_rtx, NULL_RTX, 0,
 	    emit_move_insn (target, temp);
 	}
 }
 return NULL_RTX;
-}
-/* Same as store_expr_with_bounds but ignoring bounds of EXP.  */
-rtx
-store_expr (tree exp, rtx target, int call_param_p, bool nontemporal,
-	    bool reverse)
-{
-return store_expr_with_bounds (exp, target, call_param_p, nontemporal,
-				 reverse, NULL);
 }
 /* Return true if field F of structure TYPE is a flexible array.  */
 static bool
 case COMPLEX_TYPE:
 return 2;
 case VECTOR_TYPE:
-return TYPE_VECTOR_SUBPARTS (type);
+{
+	unsigned HOST_WIDE_INT nelts;
+	if (TYPE_VECTOR_SUBPARTS (type).is_constant (&nelts))
+	  return nelts;
+	else
+	  return -1;
+}
 case INTEGER_TYPE:
 case REAL_TYPE:
 case FIXED_POINT_TYPE:
 case ENUMERAL_TYPE:
 	  init_elts += mult;
 	  break;
 	case VECTOR_CST:
 	  {
-	    unsigned i;
+	    /* We can only construct constant-length vectors using
-	    for (i = 0; i < VECTOR_CST_NELTS (value); ++i)
+	       CONSTRUCTOR.  */
+	    unsigned int nunits = VECTOR_CST_NELTS (value).to_constant ();
+	    for (unsigned int i = 0; i < nunits; ++i)
 	      {
 		tree v = VECTOR_CST_ELT (value, i);
 		if (!initializer_zerop (v))
 		  nz_elts += mult;
 		init_elts += mult;
 necessary to go through store_field.  This is so that we can pass through
 the cleared field to let store_constructor know that we may not have to
 clear a substructure if the outer structure has already been cleared.  */
 static void
-store_constructor_field (rtx target, unsigned HOST_WIDE_INT bitsize,
+store_constructor_field (rtx target, poly_uint64 bitsize, poly_int64 bitpos,
-			 HOST_WIDE_INT bitpos,
+			 poly_uint64 bitregion_start,
-			 unsigned HOST_WIDE_INT bitregion_start,
+			 poly_uint64 bitregion_end,
-			 unsigned HOST_WIDE_INT bitregion_end,
 			 machine_mode mode,
 			 tree exp, int cleared,
 			 alias_set_type alias_set, bool reverse)
 {
+poly_int64 bytepos;
+poly_uint64 bytesize;
 if (TREE_CODE (exp) == CONSTRUCTOR
 /* We can only call store_constructor recursively if the size and
 	 bit position are on a byte boundary.  */
-&& bitpos % BITS_PER_UNIT == 0
+&& multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
-&& (bitsize > 0 && bitsize % BITS_PER_UNIT == 0)
+&& maybe_ne (bitsize, 0U)
+&& multiple_p (bitsize, BITS_PER_UNIT, &bytesize)
 /* If we have a nonzero bitpos for a register target, then we just
 	 let store_field do the bitfield handling.  This is unlikely to
 	 generate unnecessary clear instructions anyways.  */
-&& (bitpos == 0 || MEM_P (target)))
+&& (known_eq (bitpos, 0) || MEM_P (target)))
 {
 if (MEM_P (target))
-	target
+	{
-	  = adjust_address (target,
+	  machine_mode target_mode = GET_MODE (target);
-			    GET_MODE (target) == BLKmode
+	  if (target_mode != BLKmode
-			    || 0 != (bitpos
+	      && !multiple_p (bitpos, GET_MODE_ALIGNMENT (target_mode)))
-				     % GET_MODE_ALIGNMENT (GET_MODE (target)))
+	    target_mode = BLKmode;
-			    ? BLKmode : VOIDmode, bitpos / BITS_PER_UNIT);
+	  target = adjust_address (target, target_mode, bytepos);
+	}
 /* Update the alias set, if required.  */
 if (MEM_P (target) && ! MEM_KEEP_ALIAS_SET_P (target)
 	  && MEM_ALIAS_SET (target) != 0)
 	{
 	  target = copy_rtx (target);
 	  set_mem_alias_set (target, alias_set);
 	}
-store_constructor (exp, target, cleared, bitsize / BITS_PER_UNIT,
+store_constructor (exp, target, cleared, bytesize, reverse);
-			 reverse);
 }
 else
 store_field (target, bitsize, bitpos, bitregion_start, bitregion_end, mode,
 		 exp, alias_set, false, reverse);
 }
 may not be the same as the size of EXP if we are assigning to a field
 which has been packed to exclude padding bits.
 If REVERSE is true, the store is to be done in reverse order.  */
 static void
-store_constructor (tree exp, rtx target, int cleared, HOST_WIDE_INT size,
+store_constructor (tree exp, rtx target, int cleared, poly_int64 size,
 		   bool reverse)
 {
 tree type = TREE_TYPE (exp);
 HOST_WIDE_INT exp_size = int_size_in_bytes (type);
-HOST_WIDE_INT bitregion_end = size > 0 ? size * BITS_PER_UNIT - 1 : 0;
+poly_int64 bitregion_end = known_gt (size, 0) ? size * BITS_PER_UNIT - 1 : 0;
 switch (TREE_CODE (type))
 {
 case RECORD_TYPE:
 case UNION_TYPE:
 	/* The storage order is specified for every aggregate type.  */
 	reverse = TYPE_REVERSE_STORAGE_ORDER (type);
 	/* If size is zero or the target is already cleared, do nothing.  */
-	if (size == 0 || cleared)
+	if (known_eq (size, 0) || cleared)
 	  cleared = 1;
 	/* We either clear the aggregate or indicate the value is dead.  */
 	else if ((TREE_CODE (type) == UNION_TYPE
 		  || TREE_CODE (type) == QUAL_UNION_TYPE)
 		 && ! CONSTRUCTOR_ELTS (exp))
 	/* If we are building a static constructor into a register,
 	   set the initial value as zero so we can fold the value into
 	   a constant.  But if more than one register is involved,
 	   this probably loses.  */
 	else if (REG_P (target) && TREE_STATIC (exp)
-		 && GET_MODE_SIZE (GET_MODE (target)) <= UNITS_PER_WORD)
+		 && known_le (GET_MODE_SIZE (GET_MODE (target)),
+			      REGMODE_NATURAL_SIZE (GET_MODE (target))))
 	  {
 	    emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
 	    cleared = 1;
 	  }
 /* If the constructor has fewer fields than the structure or
 	   if we are initializing the structure to mostly zeros, clear
 	   the whole structure first.  Don't do this if TARGET is a
 	   register whose mode size isn't equal to SIZE since
 	   clear_storage can't handle this case.  */
-	else if (size > 0
+	else if (known_size_p (size)
 		 && (((int) CONSTRUCTOR_NELTS (exp) != fields_length (type))
 		     || mostly_zeros_p (exp))
 		 && (!REG_P (target)
-		     || ((HOST_WIDE_INT) GET_MODE_SIZE (GET_MODE (target))
+		     || known_eq (GET_MODE_SIZE (GET_MODE (target)), size)))
-			 == size)))
 	  {
-	    clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
+	    clear_storage (target, gen_int_mode (size, Pmode),
+			   BLOCK_OP_NORMAL);
 	    cleared = 1;
 	  }
 	if (REG_P (target) && !cleared)
 	  emit_clobber (target);
 		&& (count < maxelt - minelt + 1
 		    || 4 * zero_count >= 3 * count))
 	      need_to_clear = 1;
 	  }
-	if (need_to_clear && size > 0)
+	if (need_to_clear && maybe_gt (size, 0))
 	  {
 	    if (REG_P (target))
-	      emit_move_insn (target,  CONST0_RTX (GET_MODE (target)));
+	      emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
 	    else
-	      clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
+	      clear_storage (target, gen_int_mode (size, Pmode),
+			     BLOCK_OP_NORMAL);
 	    cleared = 1;
 	  }
 	if (!cleared && REG_P (target))
 	  /* Inform later passes that the old value is dead.  */
 	   corresponding element of TARGET, determined by counting the
 	   elements.  */
 	FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), i, index, value)
 	  {
 	    machine_mode mode;
-	    HOST_WIDE_INT bitsize;
+	    poly_int64 bitsize;
 	    HOST_WIDE_INT bitpos;
 	    rtx xtarget = target;
 	    if (cleared && initializer_zerop (value))
 	      continue;
 	    mode = TYPE_MODE (elttype);
-	    if (mode == BLKmode)
+	    if (mode != BLKmode)
-	      bitsize = (tree_fits_uhwi_p (TYPE_SIZE (elttype))
-			 ? tree_to_uhwi (TYPE_SIZE (elttype))
-			 : -1);
-	    else
 	      bitsize = GET_MODE_BITSIZE (mode);
+	    else if (!poly_int_tree_p (TYPE_SIZE (elttype), &bitsize))
+	      bitsize = -1;
 	    if (index != NULL_TREE && TREE_CODE (index) == RANGE_EXPR)
 	      {
 		tree lo_index = TREE_OPERAND (index, 0);
 		tree hi_index = TREE_OPERAND (index, 1);
 		    xtarget = offset_address (target, pos_rtx,
 					      highest_pow2_factor (position));
 		    xtarget = adjust_address (xtarget, mode, 0);
 		    if (TREE_CODE (value) == CONSTRUCTOR)
 		      store_constructor (value, xtarget, cleared,
-					 bitsize / BITS_PER_UNIT, reverse);
+					 exact_div (bitsize, BITS_PER_UNIT),
+					 reverse);
 		    else
 		      store_expr (value, xtarget, 0, false, reverse);
 		    /* Generate a conditional jump to exit the loop.  */
 		    exit_cond = build2 (LT_EXPR, integer_type_node,
 {
 	unsigned HOST_WIDE_INT idx;
 	constructor_elt *ce;
 	int i;
 	int need_to_clear;
-	int icode = CODE_FOR_nothing;
+	insn_code icode = CODE_FOR_nothing;
+	tree elt;
 	tree elttype = TREE_TYPE (type);
 	int elt_size = tree_to_uhwi (TYPE_SIZE (elttype));
 	machine_mode eltmode = TYPE_MODE (elttype);
 	HOST_WIDE_INT bitsize;
 	HOST_WIDE_INT bitpos;
 	rtvec vector = NULL;
-	unsigned n_elts;
+	poly_uint64 n_elts;
+	unsigned HOST_WIDE_INT const_n_elts;
 	alias_set_type alias;
 	bool vec_vec_init_p = false;
+	machine_mode mode = GET_MODE (target);
 	gcc_assert (eltmode != BLKmode);
+	/* Try using vec_duplicate_optab for uniform vectors.  */
+	if (!TREE_SIDE_EFFECTS (exp)
+	    && VECTOR_MODE_P (mode)
+	    && eltmode == GET_MODE_INNER (mode)
+	    && ((icode = optab_handler (vec_duplicate_optab, mode))
+		!= CODE_FOR_nothing)
+	    && (elt = uniform_vector_p (exp)))
+	  {
+	    struct expand_operand ops[2];
+	    create_output_operand (&ops[0], target, mode);
+	    create_input_operand (&ops[1], expand_normal (elt), eltmode);
+	    expand_insn (icode, 2, ops);
+	    if (!rtx_equal_p (target, ops[0].value))
+	      emit_move_insn (target, ops[0].value);
+	    break;
+	  }
 	n_elts = TYPE_VECTOR_SUBPARTS (type);
-	if (REG_P (target) && VECTOR_MODE_P (GET_MODE (target)))
+	if (REG_P (target)
+	    && VECTOR_MODE_P (mode)
+	    && n_elts.is_constant (&const_n_elts))
 	  {
-	    machine_mode mode = GET_MODE (target);
 	    machine_mode emode = eltmode;
 	    if (CONSTRUCTOR_NELTS (exp)
 		&& (TREE_CODE (TREE_TYPE (CONSTRUCTOR_ELT (exp, 0)->value))
 		    == VECTOR_TYPE))
 	      {
 		tree etype = TREE_TYPE (CONSTRUCTOR_ELT (exp, 0)->value);
-		gcc_assert (CONSTRUCTOR_NELTS (exp) * TYPE_VECTOR_SUBPARTS (etype)
+		gcc_assert (known_eq (CONSTRUCTOR_NELTS (exp)
-			    == n_elts);
+				      * TYPE_VECTOR_SUBPARTS (etype),
+				      n_elts));
 		emode = TYPE_MODE (etype);
 	      }
-	    icode = (int) convert_optab_handler (vec_init_optab, mode, emode);
+	    icode = convert_optab_handler (vec_init_optab, mode, emode);
 	    if (icode != CODE_FOR_nothing)
 	      {
-		unsigned int i, n = n_elts;
+		unsigned int i, n = const_n_elts;
 		if (emode != eltmode)
 		  {
 		    n = CONSTRUCTOR_NELTS (exp);
 		    vec_vec_init_p = true;
 		  zero_count += n_elts_here;
 	      }
 	    /* Clear the entire vector first if there are any missing elements,
 	       or if the incidence of zero elements is >= 75%.  */
-	    need_to_clear = (count < n_elts || 4 * zero_count >= 3 * count);
+	    need_to_clear = (maybe_lt (count, n_elts)
+			     || 4 * zero_count >= 3 * count);
 	  }
-	if (need_to_clear && size > 0 && !vector)
+	if (need_to_clear && maybe_gt (size, 0) && !vector)
 	  {
 	    if (REG_P (target))
-	      emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
+	      emit_move_insn (target, CONST0_RTX (mode));
 	    else
-	      clear_storage (target, GEN_INT (size), BLOCK_OP_NORMAL);
+	      clear_storage (target, gen_int_mode (size, Pmode),
+			     BLOCK_OP_NORMAL);
 	    cleared = 1;
 	  }
 	/* Inform later passes that the old value is dead.  */
 	if (!cleared && !vector && REG_P (target))
-	  emit_move_insn (target, CONST0_RTX (GET_MODE (target)));
+	  emit_move_insn (target, CONST0_RTX (mode));
 if (MEM_P (target))
 	  alias = MEM_ALIAS_SET (target);
 	else
 	  alias = get_alias_set (elttype);
 	      }
 	  }
 	if (vector)
 	  emit_insn (GEN_FCN (icode) (target,
-				      gen_rtx_PARALLEL (GET_MODE (target),
+				      gen_rtx_PARALLEL (mode, vector)));
-							vector)));
 	break;
 }
 default:
 gcc_unreachable ();
 If NONTEMPORAL is true, try generating a nontemporal store.
 If REVERSE is true, the store is to be done in reverse order.  */
 static rtx
-store_field (rtx target, HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
+store_field (rtx target, poly_int64 bitsize, poly_int64 bitpos,
-	     unsigned HOST_WIDE_INT bitregion_start,
+	     poly_uint64 bitregion_start, poly_uint64 bitregion_end,
-	     unsigned HOST_WIDE_INT bitregion_end,
 	     machine_mode mode, tree exp,
 	     alias_set_type alias_set, bool nontemporal,  bool reverse)
 {
 if (TREE_CODE (exp) == ERROR_MARK)
 return const0_rtx;
 /* If we have nothing to store, do nothing unless the expression has
 side-effects.  Don't do that for zero sized addressable lhs of
 calls.  */
-if (bitsize == 0
+if (known_eq (bitsize, 0)
 && (!TREE_ADDRESSABLE (TREE_TYPE (exp))
 	  || TREE_CODE (exp) != CALL_EXPR))
 return expand_expr (exp, const0_rtx, VOIDmode, EXPAND_NORMAL);
 if (GET_CODE (target) == CONCAT)
 {
 /* We're storing into a struct containing a single __complex.  */
-gcc_assert (!bitpos);
+gcc_assert (known_eq (bitpos, 0));
 return store_expr (exp, target, 0, nontemporal, reverse);
 }
 /* If the structure is in a register or if the component
 is a bit field, we cannot use addressing to access it.
 Use bit-field techniques or SUBREG to store in it.  */
+poly_int64 decl_bitsize;
 if (mode == VOIDmode
 || (mode != BLKmode && ! direct_store[(int) mode]
 	  && GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
 	  && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
 || REG_P (target)
 || GET_CODE (target) == SUBREG
 /* If the field isn't aligned enough to store as an ordinary memref,
 	 store it as a bit field.  */
 || (mode != BLKmode
 	  && ((((MEM_ALIGN (target) < GET_MODE_ALIGNMENT (mode))
-		|| bitpos % GET_MODE_ALIGNMENT (mode))
+		|| !multiple_p (bitpos, GET_MODE_ALIGNMENT (mode)))
 	       && targetm.slow_unaligned_access (mode, MEM_ALIGN (target)))
-	      || (bitpos % BITS_PER_UNIT != 0)))
+	      || !multiple_p (bitpos, BITS_PER_UNIT)))
-|| (bitsize >= 0 && mode != BLKmode
+|| (known_size_p (bitsize)
-	  && GET_MODE_BITSIZE (mode) > bitsize)
+	  && mode != BLKmode
+	  && maybe_gt (GET_MODE_BITSIZE (mode), bitsize))
 /* If the RHS and field are a constant size and the size of the
 	 RHS isn't the same size as the bitfield, we must use bitfield
 	 operations.  */
-|| (bitsize >= 0
+|| (known_size_p (bitsize)
-	  && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
+	  && poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp)))
-	  && compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)), bitsize) != 0
+	  && maybe_ne (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp))),
+		       bitsize)
 	  /* Except for initialization of full bytes from a CONSTRUCTOR, which
 	     we will handle specially below.  */
 	  && !(TREE_CODE (exp) == CONSTRUCTOR
-	       && bitsize % BITS_PER_UNIT == 0)
+	       && multiple_p (bitsize, BITS_PER_UNIT))
 	  /* And except for bitwise copying of TREE_ADDRESSABLE types,
 	     where the FIELD_DECL has the right bitsize, but TREE_TYPE (exp)
 	     includes some extra padding.  store_expr / expand_expr will in
 	     that case call get_inner_reference that will have the bitsize
 	     we check here and thus the block move will not clobber the
 	     padding that shouldn't be clobbered.  In the future we could
 	     replace the TREE_ADDRESSABLE check with a check that
 	     get_base_address needs to live in memory.  */
 	  && (!TREE_ADDRESSABLE (TREE_TYPE (exp))
 	      || TREE_CODE (exp) != COMPONENT_REF
-	      || TREE_CODE (DECL_SIZE (TREE_OPERAND (exp, 1))) != INTEGER_CST
+	      || !multiple_p (bitsize, BITS_PER_UNIT)
-	      || (bitsize % BITS_PER_UNIT != 0)
+	      || !multiple_p (bitpos, BITS_PER_UNIT)
-	      || (bitpos % BITS_PER_UNIT != 0)
+	      || !poly_int_tree_p (DECL_SIZE (TREE_OPERAND (exp, 1)),
-	      || (compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)), bitsize)
+				   &decl_bitsize)
-		  != 0)))
+	      || maybe_ne (decl_bitsize, bitsize)))
 /* If we are expanding a MEM_REF of a non-BLKmode non-addressable
 decl we must use bitfield operations.  */
-|| (bitsize >= 0
+|| (known_size_p (bitsize)
 	  && TREE_CODE (exp) == MEM_REF
 	  && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
 	  && DECL_P (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 	  && !TREE_ADDRESSABLE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 	  && DECL_MODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != BLKmode))
 nop_def = get_def_for_expr (exp, NOP_EXPR);
 if (nop_def)
 	{
 	  tree type = TREE_TYPE (exp);
 	  if (INTEGRAL_TYPE_P (type)
-	      && TYPE_PRECISION (type) < GET_MODE_BITSIZE (TYPE_MODE (type))
+	      && maybe_ne (TYPE_PRECISION (type),
-	      && bitsize == TYPE_PRECISION (type))
+			   GET_MODE_BITSIZE (TYPE_MODE (type)))
+	      && known_eq (bitsize, TYPE_PRECISION (type)))
 	    {
 	      tree op = gimple_assign_rhs1 (nop_def);
 	      type = TREE_TYPE (op);
-	      if (INTEGRAL_TYPE_P (type) && TYPE_PRECISION (type) >= bitsize)
+	      if (INTEGRAL_TYPE_P (type)
+		  && known_ge (TYPE_PRECISION (type), bitsize))
 		exp = op;
 	    }
 	}
 temp = expand_normal (exp);
+/* We don't support variable-sized BLKmode bitfields, since our
+	 handling of BLKmode is bound up with the ability to break
+	 things into words.  */
+gcc_assert (mode != BLKmode || bitsize.is_constant ());
 /* Handle calls that return values in multiple non-contiguous locations.
 	 The Irix 6 ABI has examples of this.  */
 if (GET_CODE (temp) == PARALLEL)
 	{
 	  HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
-	  scalar_int_mode temp_mode
+	  machine_mode temp_mode = GET_MODE (temp);
-	    = smallest_int_mode_for_size (size * BITS_PER_UNIT);
+	  if (temp_mode == BLKmode || temp_mode == VOIDmode)
+	    temp_mode = smallest_int_mode_for_size (size * BITS_PER_UNIT);
 	  rtx temp_target = gen_reg_rtx (temp_mode);
 	  emit_group_store (temp_target, temp, TREE_TYPE (exp), size);
 	  temp = temp_target;
 	}
 	  reverse = TYPE_REVERSE_STORAGE_ORDER (TREE_TYPE (exp));
 	  if (reverse)
 	    temp = flip_storage_order (temp_mode, temp);
-	  if (bitsize < size
+	  gcc_checking_assert (known_le (bitsize, size));
+	  if (maybe_lt (bitsize, size)
 	      && reverse ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN
-	      && !(mode == BLKmode && bitsize > BITS_PER_WORD))
+	      /* Use of to_constant for BLKmode was checked above.  */
+	      && !(mode == BLKmode && bitsize.to_constant () > BITS_PER_WORD))
 	    temp = expand_shift (RSHIFT_EXPR, temp_mode, temp,
 				 size - bitsize, NULL_RTX, 1);
 	}
 /* Unless MODE is VOIDmode or BLKmode, convert TEMP to MODE.  */
 	 a block copy.  Likewise for a BLKmode-like TARGET.  */
 if (GET_MODE (temp) == BLKmode
 	  && (GET_MODE (target) == BLKmode
 	      || (MEM_P (target)
 		  && GET_MODE_CLASS (GET_MODE (target)) == MODE_INT
-		  && (bitpos % BITS_PER_UNIT) == 0
+		  && multiple_p (bitpos, BITS_PER_UNIT)
-		  && (bitsize % BITS_PER_UNIT) == 0)))
+		  && multiple_p (bitsize, BITS_PER_UNIT))))
 	{
-	  gcc_assert (MEM_P (target) && MEM_P (temp)
+	  gcc_assert (MEM_P (target) && MEM_P (temp));
-		      && (bitpos % BITS_PER_UNIT) == 0);
+	  poly_int64 bytepos = exact_div (bitpos, BITS_PER_UNIT);
+	  poly_int64 bytesize = bits_to_bytes_round_up (bitsize);
-	  target = adjust_address (target, VOIDmode, bitpos / BITS_PER_UNIT);
+	  target = adjust_address (target, VOIDmode, bytepos);
 	  emit_block_move (target, temp,
-			   GEN_INT ((bitsize + BITS_PER_UNIT - 1)
+			   gen_int_mode (bytesize, Pmode),
-				    / BITS_PER_UNIT),
 			   BLOCK_OP_NORMAL);
 	  return const0_rtx;
 	}
 /* If the mode of TEMP is still BLKmode and BITSIZE not larger than the
 	 word size, we need to load the value (see again store_bit_field).  */
-if (GET_MODE (temp) == BLKmode && bitsize <= BITS_PER_WORD)
+if (GET_MODE (temp) == BLKmode && known_le (bitsize, BITS_PER_WORD))
 	{
 	  scalar_int_mode temp_mode = smallest_int_mode_for_size (bitsize);
 	  temp = extract_bit_field (temp, bitsize, 0, 1, NULL_RTX, temp_mode,
 				    temp_mode, false, NULL);
 	}
 /* Store the value in the bitfield.  */
+gcc_checking_assert (known_ge (bitpos, 0));
 store_bit_field (target, bitsize, bitpos,
 		       bitregion_start, bitregion_end,
 		       mode, temp, reverse);
 return const0_rtx;
 }
 else
 {
 /* Now build a reference to just the desired component.  */
-rtx to_rtx = adjust_address (target, mode, bitpos / BITS_PER_UNIT);
+rtx to_rtx = adjust_address (target, mode,
+				   exact_div (bitpos, BITS_PER_UNIT));
 if (to_rtx == target)
 	to_rtx = copy_rtx (to_rtx);
 if (!MEM_KEEP_ALIAS_SET_P (to_rtx) && MEM_ALIAS_SET (to_rtx) != 0)
 	set_mem_alias_set (to_rtx, alias_set);
 /* Above we avoided using bitfield operations for storing a CONSTRUCTOR
 	 into a target smaller than its type; handle that case now.  */
-if (TREE_CODE (exp) == CONSTRUCTOR && bitsize >= 0)
+if (TREE_CODE (exp) == CONSTRUCTOR && known_size_p (bitsize))
 	{
-	  gcc_assert (bitsize % BITS_PER_UNIT == 0);
+	  poly_int64 bytesize = exact_div (bitsize, BITS_PER_UNIT);
-	  store_constructor (exp, to_rtx, 0, bitsize / BITS_PER_UNIT, reverse);
+	  store_constructor (exp, to_rtx, 0, bytesize, reverse);
 	  return to_rtx;
 	}
 return store_expr (exp, to_rtx, 0, nontemporal, reverse);
 }
 If the field describes a variable-sized object, *PMODE is set to
 BLKmode and *PBITSIZE is set to -1.  An access cannot be made in
 this case, but the address of the object can be found.  */
 tree
-get_inner_reference (tree exp, HOST_WIDE_INT *pbitsize,
+get_inner_reference (tree exp, poly_int64_pod *pbitsize,
-		     HOST_WIDE_INT *pbitpos, tree *poffset,
+		     poly_int64_pod *pbitpos, tree *poffset,
 		     machine_mode *pmode, int *punsignedp,
 		     int *preversep, int *pvolatilep)
 {
 tree size_tree = 0;
 machine_mode mode = VOIDmode;
 bool blkmode_bitfield = false;
 tree offset = size_zero_node;
-offset_int bit_offset = 0;
+poly_offset_int bit_offset = 0;
 /* First get the mode, signedness, storage order and size.  We do this from
 just the outermost expression.  */
 *pbitsize = -1;
 if (TREE_CODE (exp) == COMPONENT_REF)
 	/* Volatile bitfields should be accessed in the mode of the
 	     field's type, not the mode computed based on the bit
 	     size.  */
 	mode = TYPE_MODE (DECL_BIT_FIELD_TYPE (field));
 else if (!DECL_BIT_FIELD (field))
-	mode = DECL_MODE (field);
+	{
+	  mode = DECL_MODE (field);
+	  /* For vector fields re-check the target flags, as DECL_MODE
+	     could have been set with different target flags than
+	     the current function has.  */
+	  if (mode == BLKmode
+	      && VECTOR_TYPE_P (TREE_TYPE (field))
+	      && VECTOR_MODE_P (TYPE_MODE_RAW (TREE_TYPE (field))))
+	    mode = TYPE_MODE (TREE_TYPE (field));
+	}
 else if (DECL_MODE (field) == BLKmode)
 	blkmode_bitfield = true;
 *punsignedp = DECL_UNSIGNED (field);
 }
 while (1)
 {
 switch (TREE_CODE (exp))
 	{
 	case BIT_FIELD_REF:
-	  bit_offset += wi::to_offset (TREE_OPERAND (exp, 2));
+	  bit_offset += wi::to_poly_offset (TREE_OPERAND (exp, 2));
 	  break;
 	case COMPONENT_REF:
 	  {
 	    tree field = TREE_OPERAND (exp, 1);
 	       type construction.  */
 	    if (this_offset == 0)
 	      break;
 	    offset = size_binop (PLUS_EXPR, offset, this_offset);
-	    bit_offset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
+	    bit_offset += wi::to_poly_offset (DECL_FIELD_BIT_OFFSET (field));
 	    /* ??? Right now we don't do anything with DECL_OFFSET_ALIGN.  */
 	  }
 	  break;
 	  if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR)
 	    {
 	      tree off = TREE_OPERAND (exp, 1);
 	      if (!integer_zerop (off))
 		{
-		  offset_int boff, coff = mem_ref_offset (exp);
+		  poly_offset_int boff = mem_ref_offset (exp);
-		  boff = coff << LOG2_BITS_PER_UNIT;
+		  boff <<= LOG2_BITS_PER_UNIT;
 		  bit_offset += boff;
 		}
 	      exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 	    }
 	  goto done;
 done:
 /* If OFFSET is constant, see if we can return the whole thing as a
 constant bit position.  Make sure to handle overflow during
 this conversion.  */
-if (TREE_CODE (offset) == INTEGER_CST)
+if (poly_int_tree_p (offset))
 {
-offset_int tem = wi::sext (wi::to_offset (offset),
+poly_offset_int tem = wi::sext (wi::to_poly_offset (offset),
-				 TYPE_PRECISION (sizetype));
+				      TYPE_PRECISION (sizetype));
 tem <<= LOG2_BITS_PER_UNIT;
 tem += bit_offset;
-if (wi::fits_shwi_p (tem))
+if (tem.to_shwi (pbitpos))
-	{
+	*poffset = offset = NULL_TREE;
-	  *pbitpos = tem.to_shwi ();
-	  *poffset = offset = NULL_TREE;
-	}
 }
 /* Otherwise, split it up.  */
 if (offset)
 {
 /* Avoid returning a negative bitpos as this may wreak havoc later.  */
-if (wi::neg_p (bit_offset) || !wi::fits_shwi_p (bit_offset))
+if (!bit_offset.to_shwi (pbitpos) || maybe_lt (*pbitpos, 0))
 {
-	  offset_int mask = wi::mask <offset_int> (LOG2_BITS_PER_UNIT, false);
+	  *pbitpos = num_trailing_bits (bit_offset.force_shwi ());
-	  offset_int tem = wi::bit_and_not (bit_offset, mask);
+	  poly_offset_int bytes = bits_to_bytes_round_down (bit_offset);
-	  /* TEM is the bitpos rounded to BITS_PER_UNIT towards -Inf.
-	     Subtract it to BIT_OFFSET and add it (scaled) to OFFSET.  */
-	  bit_offset -= tem;
-	  tem >>= LOG2_BITS_PER_UNIT;
 	  offset = size_binop (PLUS_EXPR, offset,
-			       wide_int_to_tree (sizetype, tem));
+			       build_int_cst (sizetype, bytes.force_shwi ()));
 	}
-*pbitpos = bit_offset.to_shwi ();
 *poffset = offset;
 }
 /* We can use BLKmode for a byte-aligned BLKmode bitfield.  */
 if (mode == VOIDmode
 && blkmode_bitfield
-&& (*pbitpos % BITS_PER_UNIT) == 0
+&& multiple_p (*pbitpos, BITS_PER_UNIT)
-&& (*pbitsize % BITS_PER_UNIT) == 0)
+&& multiple_p (*pbitsize, BITS_PER_UNIT))
 *pmode = BLKmode;
 else
 *pmode = mode;
 return exp;
 expand_expr_addr_expr_1 (tree exp, rtx target, scalar_int_mode tmode,
 		         enum expand_modifier modifier, addr_space_t as)
 {
 rtx result, subtarget;
 tree inner, offset;
-HOST_WIDE_INT bitsize, bitpos;
+poly_int64 bitsize, bitpos;
 int unsignedp, reversep, volatilep = 0;
 machine_mode mode1;
 /* If we are taking the address of a constant and are at the top level,
 we have to use output_constant_def since we can't call force_const_mem
 	tree tem = TREE_OPERAND (exp, 0);
 	if (!integer_zerop (TREE_OPERAND (exp, 1)))
 	  tem = fold_build_pointer_plus (tem, TREE_OPERAND (exp, 1));
 	return expand_expr (tem, target, tmode, modifier);
 }
+case TARGET_MEM_REF:
+return addr_for_mem_ref (exp, as, true);
 case CONST_DECL:
 /* Expand the initializer like constants above.  */
 result = XEXP (expand_expr_constant (DECL_INITIAL (exp),
 					   0, modifier), 0);
 }
 /* We must have made progress.  */
 gcc_assert (inner != exp);
-subtarget = offset || bitpos ? NULL_RTX : target;
+subtarget = offset || maybe_ne (bitpos, 0) ? NULL_RTX : target;
 /* For VIEW_CONVERT_EXPR, where the outer alignment is bigger than
 inner alignment, force the inner to be sufficiently aligned.  */
 if (CONSTANT_CLASS_P (inner)
 && TYPE_ALIGN (TREE_TYPE (inner)) < TYPE_ALIGN (TREE_TYPE (exp)))
 {
 if (modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
 	result = simplify_gen_binary (PLUS, tmode, result, tmp);
 else
 	{
-	  subtarget = bitpos ? NULL_RTX : target;
+	  subtarget = maybe_ne (bitpos, 0) ? NULL_RTX : target;
 	  result = expand_simple_binop (tmode, PLUS, result, tmp, subtarget,
 					1, OPTAB_LIB_WIDEN);
 	}
 }
-if (bitpos)
+if (maybe_ne (bitpos, 0))
 {
 /* Someone beforehand should have rejected taking the address
-	 of such an object.  */
+	 of an object that isn't byte-aligned.  */
-gcc_assert ((bitpos % BITS_PER_UNIT) == 0);
+poly_int64 bytepos = exact_div (bitpos, BITS_PER_UNIT);
 result = convert_memory_address_addr_space (tmode, result, as);
-result = plus_constant (tmode, result, bitpos / BITS_PER_UNIT);
+result = plus_constant (tmode, result, bytepos);
 if (modifier < EXPAND_SUM)
 	result = force_operand (result, target);
 }
 return result;
 	    {
 	      gcc_assert (REG_P (target)
 			  && !TYPE_REVERSE_STORAGE_ORDER (type));
 	      /* Store this field into a union of the proper type.  */
+	      poly_uint64 op0_size
+		= tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (treeop0)));
+	      poly_uint64 union_size = GET_MODE_BITSIZE (mode);
 	      store_field (target,
-			   MIN ((int_size_in_bytes (TREE_TYPE
+			   /* The conversion must be constructed so that
-						    (treeop0))
+			      we know at compile time how many bits
-				 * BITS_PER_UNIT),
+			      to preserve.  */
-				(HOST_WIDE_INT) GET_MODE_BITSIZE (mode)),
+			   ordered_min (op0_size, union_size),
 			   0, 0, 0, TYPE_MODE (valtype), treeop0, 0,
 			   false, false);
 	    }
 	  /* Return the entire union.  */
 expand_operands (treeop0, treeop1,
 		       subtarget, &op0, &op1, modifier);
 return REDUCE_BIT_FIELD (simplify_gen_binary (PLUS, mode, op0, op1));
 case MINUS_EXPR:
+case POINTER_DIFF_EXPR:
 do_minus:
 /* For initializers, we are allowed to return a MINUS of two
 	 symbolic constants.  Here we handle all cases when both operands
 	 are constant.  */
 /* Handle difference of two symbolic constants,
 	  && (TYPE_UNSIGNED (TREE_TYPE (treeop0))
 	      != TYPE_UNSIGNED (TREE_TYPE (treeop1))))
 	{
 	  machine_mode innermode = TYPE_MODE (TREE_TYPE (treeop0));
 	  this_optab = usmul_widen_optab;
-	  if (find_widening_optab_handler (this_optab, mode, innermode, 0)
+	  if (find_widening_optab_handler (this_optab, mode, innermode)
 		!= CODE_FOR_nothing)
 	    {
 	      if (TYPE_UNSIGNED (TREE_TYPE (treeop0)))
 		expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1,
 				 EXPAND_NORMAL);
 	  optab other_optab = zextend_p ? smul_widen_optab : umul_widen_optab;
 	  this_optab = zextend_p ? umul_widen_optab : smul_widen_optab;
 	  if (TREE_CODE (treeop0) != INTEGER_CST)
 	    {
-	      if (find_widening_optab_handler (this_optab, mode, innermode, 0)
+	      if (find_widening_optab_handler (this_optab, mode, innermode)
 		    != CODE_FOR_nothing)
 		{
 		  expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1,
 				   EXPAND_NORMAL);
 		  /* op0 and op1 might still be constant, despite the above
 		    }
 		  temp = expand_widening_mult (mode, op0, op1, target,
 					       unsignedp, this_optab);
 		  return REDUCE_BIT_FIELD (temp);
 		}
-	      if (find_widening_optab_handler (other_optab, mode, innermode, 0)
+	      if (find_widening_optab_handler (other_optab, mode, innermode)
 		    != CODE_FOR_nothing
 		  && innermode == word_mode)
 		{
 		  rtx htem, hipart;
 		  op0 = expand_normal (treeop0);
 	}
 treeop0 = fold_build1 (CONVERT_EXPR, type, treeop0);
 treeop1 = fold_build1 (CONVERT_EXPR, type, treeop1);
 expand_operands (treeop0, treeop1, subtarget, &op0, &op1, EXPAND_NORMAL);
 return REDUCE_BIT_FIELD (expand_mult (mode, op0, op1, target, unsignedp));
-case FMA_EXPR:
-{
-	optab opt = fma_optab;
-	gimple *def0, *def2;
-	/* If there is no insn for FMA, emit it as __builtin_fma{,f,l}
-	   call.  */
-	if (optab_handler (fma_optab, mode) == CODE_FOR_nothing)
-	  {
-	    tree fn = mathfn_built_in (TREE_TYPE (treeop0), BUILT_IN_FMA);
-	    tree call_expr;
-	    gcc_assert (fn != NULL_TREE);
-	    call_expr = build_call_expr (fn, 3, treeop0, treeop1, treeop2);
-	    return expand_builtin (call_expr, target, subtarget, mode, false);
-	  }
-	def0 = get_def_for_expr (treeop0, NEGATE_EXPR);
-	/* The multiplication is commutative - look at its 2nd operand
-	   if the first isn't fed by a negate.  */
-	if (!def0)
-	  {
-	    def0 = get_def_for_expr (treeop1, NEGATE_EXPR);
-	    /* Swap operands if the 2nd operand is fed by a negate.  */
-	    if (def0)
-	      std::swap (treeop0, treeop1);
-	  }
-	def2 = get_def_for_expr (treeop2, NEGATE_EXPR);
-	op0 = op2 = NULL;
-	if (def0 && def2
-	    && optab_handler (fnms_optab, mode) != CODE_FOR_nothing)
-	  {
-	    opt = fnms_optab;
-	    op0 = expand_normal (gimple_assign_rhs1 (def0));
-	    op2 = expand_normal (gimple_assign_rhs1 (def2));
-	  }
-	else if (def0
-		 && optab_handler (fnma_optab, mode) != CODE_FOR_nothing)
-	  {
-	    opt = fnma_optab;
-	    op0 = expand_normal (gimple_assign_rhs1 (def0));
-	  }
-	else if (def2
-		 && optab_handler (fms_optab, mode) != CODE_FOR_nothing)
-	  {
-	    opt = fms_optab;
-	    op2 = expand_normal (gimple_assign_rhs1 (def2));
-	  }
-	if (op0 == NULL)
-	  op0 = expand_expr (treeop0, subtarget, VOIDmode, EXPAND_NORMAL);
-	if (op2 == NULL)
-	  op2 = expand_normal (treeop2);
-	op1 = expand_normal (treeop1);
-	return expand_ternary_op (TYPE_MODE (type), opt,
-				  op0, op1, op2, target, 0);
-}
 case MULT_EXPR:
 /* If this is a fixed-point operation, then we cannot use the code
 	 below because "expand_mult" doesn't support sat/no-sat fixed-point
 multiplications.   */
 			  op0, target, 0);
 gcc_assert (temp);
 return REDUCE_BIT_FIELD (temp);
 case ABS_EXPR:
+case ABSU_EXPR:
 op0 = expand_expr (treeop0, subtarget,
 			 VOIDmode, EXPAND_NORMAL);
 if (modifier == EXPAND_STACK_PARM)
 	target = 0;
 gcc_assert (GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
 		  && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT);
 /* Unsigned abs is simply the operand.  Testing here means we don't
 	 risk generating incorrect code below.  */
-if (TYPE_UNSIGNED (type))
+if (TYPE_UNSIGNED (TREE_TYPE (treeop0)))
 	return op0;
 return expand_abs (mode, op0, target, unsignedp,
 			 safe_from_p (target, treeop0, 1));
 		    && TREE_INT_CST_LOW (treeop1) < GET_MODE_BITSIZE (word_mode)
 		    && ((TREE_INT_CST_LOW (treeop1) + GET_MODE_BITSIZE (rmode))
 			>= GET_MODE_BITSIZE (word_mode)))
 		  {
 		    rtx_insn *seq, *seq_old;
-		    unsigned int high_off = subreg_highpart_offset (word_mode,
+		    poly_uint64 high_off = subreg_highpart_offset (word_mode,
-								    int_mode);
+								   int_mode);
 		    bool extend_unsigned
 		      = TYPE_UNSIGNED (TREE_TYPE (gimple_assign_rhs1 (def)));
 		    rtx low = lowpart_subreg (word_mode, op0, int_mode);
 		    rtx dest_low = lowpart_subreg (word_mode, target, int_mode);
 		    rtx dest_high = simplify_gen_subreg (word_mode, target,
 target = expand_widen_pattern_expr (ops, op0, NULL_RTX, op1,
 target, unsignedp);
 return target;
 }
-case REDUC_MAX_EXPR:
-case REDUC_MIN_EXPR:
-case REDUC_PLUS_EXPR:
-{
-op0 = expand_normal (treeop0);
-this_optab = optab_for_tree_code (code, type, optab_default);
-machine_mode vec_mode = TYPE_MODE (TREE_TYPE (treeop0));
-	struct expand_operand ops[2];
-	enum insn_code icode = optab_handler (this_optab, vec_mode);
-	create_output_operand (&ops[0], target, mode);
-	create_input_operand (&ops[1], op0, vec_mode);
-	expand_insn (icode, 2, ops);
-	target = ops[0].value;
-	if (GET_MODE (target) != mode)
-	  return gen_lowpart (tmode, target);
-	return target;
-}
 case VEC_UNPACK_HI_EXPR:
 case VEC_UNPACK_LO_EXPR:
+case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
+case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
 {
 	op0 = expand_normal (treeop0);
 	temp = expand_widen_pattern_expr (ops, op0, NULL_RTX, NULL_RTX,
 					  target, unsignedp);
 	gcc_assert (temp);
 case VEC_PACK_SAT_EXPR:
 case VEC_PACK_FIX_TRUNC_EXPR:
 mode = TYPE_MODE (TREE_TYPE (treeop0));
 goto binop;
+case VEC_PACK_FLOAT_EXPR:
+mode = TYPE_MODE (TREE_TYPE (treeop0));
+expand_operands (treeop0, treeop1,
+		       subtarget, &op0, &op1, EXPAND_NORMAL);
+this_optab = optab_for_tree_code (code, TREE_TYPE (treeop0),
+					optab_default);
+target = expand_binop (mode, this_optab, op0, op1, target,
+			     TYPE_UNSIGNED (TREE_TYPE (treeop0)),
+			     OPTAB_LIB_WIDEN);
+gcc_assert (target);
+return target;
 case VEC_PERM_EXPR:
-expand_operands (treeop0, treeop1, target, &op0, &op1, EXPAND_NORMAL);
+{
-op2 = expand_normal (treeop2);
+	expand_operands (treeop0, treeop1, target, &op0, &op1, EXPAND_NORMAL);
+	vec_perm_builder sel;
-/* Careful here: if the target doesn't support integral vector modes,
+	if (TREE_CODE (treeop2) == VECTOR_CST
-	 a constant selection vector could wind up smooshed into a normal
+	    && tree_to_vec_perm_builder (&sel, treeop2))
-	 integral constant.  */
+	  {
-if (CONSTANT_P (op2) && GET_CODE (op2) != CONST_VECTOR)
+	    machine_mode sel_mode = TYPE_MODE (TREE_TYPE (treeop2));
-	{
+	    temp = expand_vec_perm_const (mode, op0, op1, sel,
-	  tree sel_type = TREE_TYPE (treeop2);
+					  sel_mode, target);
-	  machine_mode vmode
+	  }
-	    = mode_for_vector (SCALAR_TYPE_MODE (TREE_TYPE (sel_type)),
+	else
-			       TYPE_VECTOR_SUBPARTS (sel_type)).require ();
+	  {
-	  gcc_assert (GET_MODE_CLASS (vmode) == MODE_VECTOR_INT);
+	    op2 = expand_normal (treeop2);
-	  op2 = simplify_subreg (vmode, op2, TYPE_MODE (sel_type), 0);
+	    temp = expand_vec_perm_var (mode, op0, op1, op2, target);
-	  gcc_assert (op2 && GET_CODE (op2) == CONST_VECTOR);
+	  }
-	}
+	gcc_assert (temp);
-else
+	return temp;
-gcc_assert (GET_MODE_CLASS (GET_MODE (op2)) == MODE_VECTOR_INT);
+}
-temp = expand_vec_perm (mode, op0, op1, op2, target);
-gcc_assert (temp);
-return temp;
 case DOT_PROD_EXPR:
 {
 	tree oprnd0 = treeop0;
 	tree oprnd1 = treeop1;
 }
 case VEC_COND_EXPR:
 target = expand_vec_cond_expr (type, treeop0, treeop1, treeop2, target);
 return target;
+case VEC_DUPLICATE_EXPR:
+op0 = expand_expr (treeop0, NULL_RTX, VOIDmode, modifier);
+target = expand_vector_broadcast (mode, op0);
+gcc_assert (target);
+return target;
+case VEC_SERIES_EXPR:
+expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1, modifier);
+return expand_vec_series_expr (mode, op0, op1, target);
 case BIT_INSERT_EXPR:
 {
 	unsigned bitpos = tree_to_uhwi (treeop2);
 	unsigned bitsize;
 }
 case VECTOR_CST:
 {
 	tree tmp = NULL_TREE;
-	if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT
+	if (VECTOR_MODE_P (mode))
-	    || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT
-	    || GET_MODE_CLASS (mode) == MODE_VECTOR_FRACT
-	    || GET_MODE_CLASS (mode) == MODE_VECTOR_UFRACT
-	    || GET_MODE_CLASS (mode) == MODE_VECTOR_ACCUM
-	    || GET_MODE_CLASS (mode) == MODE_VECTOR_UACCUM)
 	  return const_vector_from_tree (exp);
 	scalar_int_mode int_mode;
 	if (is_int_mode (mode, &int_mode))
 	  {
 	    if (VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (exp)))
 	      }
 	  }
 	if (!tmp)
 	  {
 	    vec<constructor_elt, va_gc> *v;
-	    unsigned i;
+	    /* Constructors need to be fixed-length.  FIXME.  */
-	    vec_alloc (v, VECTOR_CST_NELTS (exp));
+	    unsigned int nunits = VECTOR_CST_NELTS (exp).to_constant ();
-	    for (i = 0; i < VECTOR_CST_NELTS (exp); ++i)
+	    vec_alloc (v, nunits);
+	    for (unsigned int i = 0; i < nunits; ++i)
 	      CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, VECTOR_CST_ELT (exp, i));
 	    tmp = build_constructor (type, v);
 	  }
 	return expand_expr (tmp, ignore ? const0_rtx : target,
 			    tmode, modifier);
 	  && ! memory_address_addr_space_p (mode, XEXP (temp, 0),
 					    MEM_ADDR_SPACE (temp)))
 	return replace_equiv_address (temp,
 				      copy_rtx (XEXP (temp, 0)));
 return temp;
+case POLY_INT_CST:
+return immed_wide_int_const (poly_int_cst_value (exp), mode);
 case SAVE_EXPR:
 {
 	tree val = treeop0;
 	rtx ret = expand_expr_real_1 (val, target, tmode, modifier, alt_rtl,
 	unsigned align;
 	/* Handle expansion of non-aliased memory with non-BLKmode.  That
 	   might end up in a register.  */
 	if (mem_ref_refers_to_non_mem_p (exp))
 	  {
-	    HOST_WIDE_INT offset = mem_ref_offset (exp).to_short_addr ();
+	    poly_int64 offset = mem_ref_offset (exp).force_shwi ();
 	    base = TREE_OPERAND (base, 0);
-	    if (offset == 0
+	    poly_uint64 type_size;
+	    if (known_eq (offset, 0)
 	        && !reverse
-		&& tree_fits_uhwi_p (TYPE_SIZE (type))
+		&& poly_int_tree_p (TYPE_SIZE (type), &type_size)
-		&& (GET_MODE_BITSIZE (DECL_MODE (base))
+		&& known_eq (GET_MODE_BITSIZE (DECL_MODE (base)), type_size))
-		    == tree_to_uhwi (TYPE_SIZE (type))))
 	      return expand_expr (build1 (VIEW_CONVERT_EXPR, type, base),
 				  target, tmode, modifier);
 	    if (TYPE_MODE (type) == BLKmode)
 	      {
 		temp = assign_stack_temp (DECL_MODE (base),
 case BIT_FIELD_REF:
 case ARRAY_RANGE_REF:
 normal_inner_ref:
 {
 	machine_mode mode1, mode2;
-	HOST_WIDE_INT bitsize, bitpos;
+	poly_int64 bitsize, bitpos, bytepos;
 	tree offset;
 	int reversep, volatilep = 0, must_force_mem;
 	tree tem
 	  = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode1,
 				 &unsignedp, &reversep, &volatilep);
 	  }
 	mode2
 	  = CONSTANT_P (op0) ? TYPE_MODE (TREE_TYPE (tem)) : GET_MODE (op0);
+	/* Make sure bitpos is not negative, it can wreak havoc later.  */
+	if (maybe_lt (bitpos, 0))
+	  {
+	    gcc_checking_assert (offset == NULL_TREE);
+	    offset = size_int (bits_to_bytes_round_down (bitpos));
+	    bitpos = num_trailing_bits (bitpos);
+	  }
 	/* If we have either an offset, a BLKmode result, or a reference
 	   outside the underlying object, we must force it to memory.
 	   Such a case can occur in Ada if we have unchecked conversion
 	   of an expression from a scalar type to an aggregate type or
 	   for an ARRAY_RANGE_REF whose type is BLKmode, or if we were
 	   passed a partially uninitialized object or a view-conversion
 	   to a larger size.  */
 	must_force_mem = (offset
 			  || mode1 == BLKmode
-			  || bitpos + bitsize > GET_MODE_BITSIZE (mode2));
+			  || (mode == BLKmode
+			      && !int_mode_for_size (bitsize, 1).exists ())
+			  || maybe_gt (bitpos + bitsize,
+				       GET_MODE_BITSIZE (mode2)));
 	/* Handle CONCAT first.  */
 	if (GET_CODE (op0) == CONCAT && !must_force_mem)
 	  {
-	    if (bitpos == 0
+	    if (known_eq (bitpos, 0)
-		&& bitsize == GET_MODE_BITSIZE (GET_MODE (op0))
+		&& known_eq (bitsize, GET_MODE_BITSIZE (GET_MODE (op0)))
 		&& COMPLEX_MODE_P (mode1)
 		&& COMPLEX_MODE_P (GET_MODE (op0))
 		&& (GET_MODE_PRECISION (GET_MODE_INNER (mode1))
 		    == GET_MODE_PRECISION (GET_MODE_INNER (GET_MODE (op0)))))
 	      {
 		      }
 		    op0 = gen_rtx_CONCAT (mode1, parts[0], parts[1]);
 		  }
 		return op0;
 	      }
-	    if (bitpos == 0
+	    if (known_eq (bitpos, 0)
-		&& bitsize == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
+		&& known_eq (bitsize,
-		&& bitsize)
+			     GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))))
+		&& maybe_ne (bitsize, 0))
 	      {
 		op0 = XEXP (op0, 0);
 		mode2 = GET_MODE (op0);
 	      }
-	    else if (bitpos == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
+	    else if (known_eq (bitpos,
-		     && bitsize == GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 1)))
+			       GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))))
-		     && bitpos
+		     && known_eq (bitsize,
-		     && bitsize)
+				  GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 1))))
+		     && maybe_ne (bitpos, 0)
+		     && maybe_ne (bitsize, 0))
 	      {
 		op0 = XEXP (op0, 1);
 		bitpos = 0;
 		mode2 = GET_MODE (op0);
 	      }
 		offset_rtx = convert_to_mode (address_mode, offset_rtx, 0);
 	      }
 	    /* See the comment in expand_assignment for the rationale.  */
 	    if (mode1 != VOIDmode
-		&& bitpos != 0
+		&& maybe_ne (bitpos, 0)
-		&& bitsize > 0
+		&& maybe_gt (bitsize, 0)
-		&& (bitpos % bitsize) == 0
+		&& multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
-		&& (bitsize % GET_MODE_ALIGNMENT (mode1)) == 0
+		&& multiple_p (bitpos, bitsize)
+		&& multiple_p (bitsize, GET_MODE_ALIGNMENT (mode1))
 		&& MEM_ALIGN (op0) >= GET_MODE_ALIGNMENT (mode1))
 	      {
-		op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
+		op0 = adjust_address (op0, mode1, bytepos);
 		bitpos = 0;
 	      }
 	    op0 = offset_address (op0, offset_rtx,
 				  highest_pow2_factor (offset));
 	  }
 	/* If OFFSET is making OP0 more aligned than BIGGEST_ALIGNMENT,
 	   record its alignment as BIGGEST_ALIGNMENT.  */
-	if (MEM_P (op0) && bitpos == 0 && offset != 0
+	if (MEM_P (op0)
+	    && known_eq (bitpos, 0)
+	    && offset != 0
 	    && is_aligning_offset (offset, tem))
 	  set_mem_align (op0, BIGGEST_ALIGNMENT);
 	/* Don't forget about volatility even if this is a bitfield.  */
 	if (MEM_P (op0) && volatilep && ! MEM_VOLATILE_P (op0))
 	       is narrower than the access size of the bitfield,
 	       we need to extract bitfields from the access.  */
 	    || (volatilep && TREE_CODE (exp) == COMPONENT_REF
 		&& DECL_BIT_FIELD_TYPE (TREE_OPERAND (exp, 1))
 		&& mode1 != BLKmode
-		&& bitsize < GET_MODE_SIZE (mode1) * BITS_PER_UNIT)
+		&& maybe_lt (bitsize, GET_MODE_SIZE (mode1) * BITS_PER_UNIT))
 	    /* If the field isn't aligned enough to fetch as a memref,
 	       fetch it as a bit field.  */
 	    || (mode1 != BLKmode
 		&& (((MEM_P (op0)
 		      ? MEM_ALIGN (op0) < GET_MODE_ALIGNMENT (mode1)
-		        || (bitpos % GET_MODE_ALIGNMENT (mode1) != 0)
+			|| !multiple_p (bitpos, GET_MODE_ALIGNMENT (mode1))
 		      : TYPE_ALIGN (TREE_TYPE (tem)) < GET_MODE_ALIGNMENT (mode)
-		        || (bitpos % GET_MODE_ALIGNMENT (mode) != 0))
+			|| !multiple_p (bitpos, GET_MODE_ALIGNMENT (mode)))
 		     && modifier != EXPAND_MEMORY
 		     && ((modifier == EXPAND_CONST_ADDRESS
 			  || modifier == EXPAND_INITIALIZER)
 			 ? STRICT_ALIGNMENT
 			 : targetm.slow_unaligned_access (mode1,
 							  MEM_ALIGN (op0))))
-		    || (bitpos % BITS_PER_UNIT != 0)))
+		    || !multiple_p (bitpos, BITS_PER_UNIT)))
 	    /* If the type and the field are a constant size and the
 	       size of the type isn't the same size as the bitfield,
 	       we must use bitfield operations.  */
-	    || (bitsize >= 0
+	    || (known_size_p (bitsize)
 		&& TYPE_SIZE (TREE_TYPE (exp))
-		&& TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) == INTEGER_CST
+		&& poly_int_tree_p (TYPE_SIZE (TREE_TYPE (exp)))
-		&& 0 != compare_tree_int (TYPE_SIZE (TREE_TYPE (exp)),
+		&& maybe_ne (wi::to_poly_offset (TYPE_SIZE (TREE_TYPE (exp))),
-					  bitsize)))
+			     bitsize)))
 	  {
 	    machine_mode ext_mode = mode;
 	    if (ext_mode == BLKmode
 		&& ! (target != 0 && MEM_P (op0)
 		      && MEM_P (target)
-		      && bitpos % BITS_PER_UNIT == 0))
+		      && multiple_p (bitpos, BITS_PER_UNIT)))
 	      ext_mode = int_mode_for_size (bitsize, 1).else_blk ();
 	    if (ext_mode == BLKmode)
 	      {
 		if (target == 0)
 		  target = assign_temp (type, 1, 1);
 		/* ??? Unlike the similar test a few lines below, this one is
 		   very likely obsolete.  */
-		if (bitsize == 0)
+		if (known_eq (bitsize, 0))
 		  return target;
 		/* In this case, BITPOS must start at a byte boundary and
 		   TARGET, if specified, must be a MEM.  */
 		gcc_assert (MEM_P (op0)
-			    && (!target || MEM_P (target))
+			    && (!target || MEM_P (target)));
-			    && !(bitpos % BITS_PER_UNIT));
+		bytepos = exact_div (bitpos, BITS_PER_UNIT);
+		poly_int64 bytesize = bits_to_bytes_round_up (bitsize);
 		emit_block_move (target,
-				 adjust_address (op0, VOIDmode,
+				 adjust_address (op0, VOIDmode, bytepos),
-						 bitpos / BITS_PER_UNIT),
+				 gen_int_mode (bytesize, Pmode),
-				 GEN_INT ((bitsize + BITS_PER_UNIT - 1)
-					  / BITS_PER_UNIT),
 				 (modifier == EXPAND_STACK_PARM
 				  ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
 		return target;
 	      }
 	    /* If we have nothing to extract, the result will be 0 for targets
 	       with SHIFT_COUNT_TRUNCATED == 0 and garbage otherwise.  Always
 	       return 0 for the sake of consistency, as reading a zero-sized
 	       bitfield is valid in Ada and the value is fully specified.  */
-	    if (bitsize == 0)
+	    if (known_eq (bitsize, 0))
 	      return const0_rtx;
 	    op0 = validize_mem (op0);
 	    if (MEM_P (op0) && REG_P (XEXP (op0, 0)))
 	       order and put back into memory order afterwards.  */
 	    if (TREE_CODE (type) == RECORD_TYPE
 		&& GET_MODE_CLASS (ext_mode) == MODE_INT)
 	      reversep = TYPE_REVERSE_STORAGE_ORDER (type);
+	    gcc_checking_assert (known_ge (bitpos, 0));
 	    op0 = extract_bit_field (op0, bitsize, bitpos, unsignedp,
 				     (modifier == EXPAND_STACK_PARM
 				      ? NULL_RTX : target),
 				     ext_mode, ext_mode, reversep, alt_rtl);
 	    if (TREE_CODE (type) == RECORD_TYPE
 		&& is_int_mode (GET_MODE (op0), &op0_mode))
 	      {
 		HOST_WIDE_INT size = GET_MODE_BITSIZE (op0_mode);
-		if (bitsize < size
+		gcc_checking_assert (known_le (bitsize, size));
+		if (maybe_lt (bitsize, size)
 		    && reversep ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)
 		  op0 = expand_shift (LSHIFT_EXPR, op0_mode, op0,
 				      size - bitsize, op0, 1);
 		if (reversep)
 	   now as well.  */
 	if (mode == BLKmode)
 	  mode1 = BLKmode;
 	/* Get a reference to just this component.  */
+	bytepos = bits_to_bytes_round_down (bitpos);
 	if (modifier == EXPAND_CONST_ADDRESS
 	    || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
-	  op0 = adjust_address_nv (op0, mode1, bitpos / BITS_PER_UNIT);
+	  op0 = adjust_address_nv (op0, mode1, bytepos);
 	else
-	  op0 = adjust_address (op0, mode1, bitpos / BITS_PER_UNIT);
+	  op0 = adjust_address (op0, mode1, bytepos);
 	if (op0 == orig_op0)
 	  op0 = copy_rtx (op0);
 	/* Don't set memory attributes if the base expression is
 	error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
 {
 	tree fndecl = get_callee_fndecl (exp), attr;
 	if (fndecl
+	    /* Don't diagnose the error attribute in thunks, those are
+	       artificially created.  */
+	    && !CALL_FROM_THUNK_P (exp)
 	    && (attr = lookup_attribute ("error",
 					 DECL_ATTRIBUTES (fndecl))) != NULL)
-	  error ("%Kcall to %qs declared with attribute error: %s",
+	  {
-		 exp, identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 1)),
+	    const char *ident = lang_hooks.decl_printable_name (fndecl, 1);
-		 TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))));
+	    error ("%Kcall to %qs declared with attribute error: %s", exp,
+		   identifier_to_locale (ident),
+		   TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))));
+	  }
 	if (fndecl
+	    /* Don't diagnose the warning attribute in thunks, those are
+	       artificially created.  */
+	    && !CALL_FROM_THUNK_P (exp)
 	    && (attr = lookup_attribute ("warning",
 					 DECL_ATTRIBUTES (fndecl))) != NULL)
-	  warning_at (tree_nonartificial_location (exp),
+	  {
-		      0, "%Kcall to %qs declared with attribute warning: %s",
+	    const char *ident = lang_hooks.decl_printable_name (fndecl, 1);
-		      exp, identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 1)),
+	    warning_at (tree_nonartificial_location (exp), 0,
-		      TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))));
+			"%Kcall to %qs declared with attribute warning: %s",
+			exp, identifier_to_locale (ident),
+			TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))));
+	  }
 	/* Check for a built-in function.  */
-	if (fndecl && DECL_BUILT_IN (fndecl))
+	if (fndecl && fndecl_built_in_p (fndecl))
 	  {
 	    gcc_assert (DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_FRONTEND);
-	    if (CALL_WITH_BOUNDS_P (exp))
+	    return expand_builtin (exp, target, subtarget, tmode, ignore);
-	      return expand_builtin_with_bounds (exp, target, subtarget,
-						 tmode, ignore);
-	    else
-	      return expand_builtin (exp, target, subtarget, tmode, ignore);
 	  }
 }
 return expand_call (exp, target, ignore);
 case VIEW_CONVERT_EXPR:
 op0 = NULL_RTX;
 /* If we are converting to BLKmode, try to avoid an intermediate
 	 temporary by fetching an inner memory reference.  */
 if (mode == BLKmode
-	  && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
+	  && poly_int_tree_p (TYPE_SIZE (type))
 	  && TYPE_MODE (TREE_TYPE (treeop0)) != BLKmode
 	  && handled_component_p (treeop0))
 {
 	machine_mode mode1;
-	HOST_WIDE_INT bitsize, bitpos;
+	poly_int64 bitsize, bitpos, bytepos;
 	tree offset;
 	int unsignedp, reversep, volatilep = 0;
 	tree tem
 	  = get_inner_reference (treeop0, &bitsize, &bitpos, &offset, &mode1,
 				 &unsignedp, &reversep, &volatilep);
 	rtx orig_op0;
 	/* ??? We should work harder and deal with non-zero offsets.  */
 	if (!offset
-	    && (bitpos % BITS_PER_UNIT) == 0
+	    && multiple_p (bitpos, BITS_PER_UNIT, &bytepos)
 	    && !reversep
-	    && bitsize >= 0
+	    && known_size_p (bitsize)
-	    && compare_tree_int (TYPE_SIZE (type), bitsize) == 0)
+	    && known_eq (wi::to_poly_offset (TYPE_SIZE (type)), bitsize))
 	  {
 	    /* See the normal_inner_ref case for the rationale.  */
 	    orig_op0
 	      = expand_expr_real (tem,
 				  (TREE_CODE (TREE_TYPE (tem)) == UNION_TYPE
 		/* Get a reference to just this component.  */
 		if (modifier == EXPAND_CONST_ADDRESS
 		    || modifier == EXPAND_SUM
 		    || modifier == EXPAND_INITIALIZER)
-		  op0 = adjust_address_nv (op0, mode, bitpos / BITS_PER_UNIT);
+		  op0 = adjust_address_nv (op0, mode, bytepos);
 		else
-		  op0 = adjust_address (op0, mode, bitpos / BITS_PER_UNIT);
+		  op0 = adjust_address (op0, mode, bytepos);
 		if (op0 == orig_op0)
 		  op0 = copy_rtx (op0);
 		set_mem_attributes (op0, treeop0, 0);
 /* If the input and output modes are both the same, we are done.  */
 if (mode == GET_MODE (op0))
 	;
 /* If neither mode is BLKmode, and both modes are the same size
 	 then we can use gen_lowpart.  */
-else if (mode != BLKmode && GET_MODE (op0) != BLKmode
+else if (mode != BLKmode
-	       && (GET_MODE_PRECISION (mode)
+	       && GET_MODE (op0) != BLKmode
-		   == GET_MODE_PRECISION (GET_MODE (op0)))
+	       && known_eq (GET_MODE_PRECISION (mode),
+			    GET_MODE_PRECISION (GET_MODE (op0)))
 	       && !COMPLEX_MODE_P (GET_MODE (op0)))
 	{
 	  if (GET_CODE (op0) == SUBREG)
 	    op0 = force_reg (GET_MODE (op0), op0);
 	  temp = gen_lowpart_common (mode, op0);
 		  emit_insn (insn);
 		  return reg;
 		}
 	      else if (STRICT_ALIGNMENT)
 		{
-		  tree inner_type = TREE_TYPE (treeop0);
+		  poly_uint64 mode_size = GET_MODE_SIZE (mode);
-		  HOST_WIDE_INT temp_size
+		  poly_uint64 temp_size = mode_size;
-		    = MAX (int_size_in_bytes (inner_type),
+		  if (GET_MODE (op0) != BLKmode)
-			   (HOST_WIDE_INT) GET_MODE_SIZE (mode));
+		    temp_size = upper_bound (temp_size,
+					     GET_MODE_SIZE (GET_MODE (op0)));
 		  rtx new_rtx
 		    = assign_stack_temp_for_type (mode, temp_size, type);
 		  rtx new_with_op0_mode
 		    = adjust_address (new_rtx, GET_MODE (op0), 0);
 		  gcc_assert (!TREE_ADDRESSABLE (exp));
 		  if (GET_MODE (op0) == BLKmode)
-		    emit_block_move (new_with_op0_mode, op0,
+		    {
-				     GEN_INT (GET_MODE_SIZE (mode)),
+		      rtx size_rtx = gen_int_mode (mode_size, Pmode);
-				     (modifier == EXPAND_STACK_PARM
+		      emit_block_move (new_with_op0_mode, op0, size_rtx,
-				      ? BLOCK_OP_CALL_PARM : BLOCK_OP_NORMAL));
+				       (modifier == EXPAND_STACK_PARM
+					? BLOCK_OP_CALL_PARM
+					: BLOCK_OP_NORMAL));
+		    }
 		  else
 		    emit_move_insn (new_with_op0_mode, op0);
 		  op0 = new_rtx;
 		}
 	    && integer_onep (DECL_SIZE (TREE_OPERAND (lhs, 1)))
 	    && integer_onep (DECL_SIZE (TREE_OPERAND (TREE_OPERAND (rhs, 1), 1))))
 	  {
 	    rtx_code_label *label = gen_label_rtx ();
 	    int value = TREE_CODE (rhs) == BIT_IOR_EXPR;
-	    do_jump (TREE_OPERAND (rhs, 1),
+	    profile_probability prob = profile_probability::uninitialized ();
-		     value ? label : 0,
+	    if (value)
-		     value ? 0 : label,
+	      jumpifnot (TREE_OPERAND (rhs, 1), label, prob);
-		     profile_probability::uninitialized ());
+	    else
+	      jumpif (TREE_OPERAND (rhs, 1), label, prob);
 	    expand_assignment (lhs, build_int_cst (TREE_TYPE (rhs), value),
 			       false);
 	    do_pending_stack_adjust ();
 	    emit_label (label);
 	    return const0_rtx;
 {
 HOST_WIDE_INT prec = TYPE_PRECISION (type);
 if (target && GET_MODE (target) != GET_MODE (exp))
 target = 0;
 /* For constant values, reduce using build_int_cst_type. */
-if (CONST_INT_P (exp))
+poly_int64 const_exp;
-{
+if (poly_int_rtx_p (exp, &const_exp))
-HOST_WIDE_INT value = INTVAL (exp);
+{
-tree t = build_int_cst_type (type, value);
+tree t = build_int_cst_type (type, const_exp);
 return expand_expr (t, target, VOIDmode, EXPAND_NORMAL);
 }
 else if (TYPE_UNSIGNED (type))
 {
 scalar_int_mode mode = as_a <scalar_int_mode> (GET_MODE (exp));
 /* This must now be the address of EXP.  */
 return TREE_CODE (offset) == ADDR_EXPR && TREE_OPERAND (offset, 0) == exp;
 }
 /* Return the tree node if an ARG corresponds to a string constant or zero
-if it doesn't.  If we return nonzero, set *PTR_OFFSET to the offset
+if it doesn't.  If we return nonzero, set *PTR_OFFSET to the (possibly
-in bytes within the string that ARG is accessing.  The type of the
+non-constant) offset in bytes within the string that ARG is accessing.
-offset will be `sizetype'.  */
+If MEM_SIZE is non-zero the storage size of the memory is returned.
+If DECL is non-zero the constant declaration is returned if available.  */
 tree
-string_constant (tree arg, tree *ptr_offset)
+string_constant (tree arg, tree *ptr_offset, tree *mem_size, tree *decl)
 {
-tree array, offset, lower_bound;
+tree array;
 STRIP_NOPS (arg);
+/* Non-constant index into the character array in an ARRAY_REF
+expression or null.  */
+tree varidx = NULL_TREE;
+poly_int64 base_off = 0;
 if (TREE_CODE (arg) == ADDR_EXPR)
 {
-if (TREE_CODE (TREE_OPERAND (arg, 0)) == STRING_CST)
+arg = TREE_OPERAND (arg, 0);
-	{
+tree ref = arg;
-	  *ptr_offset = size_zero_node;
+if (TREE_CODE (arg) == ARRAY_REF)
-	  return TREE_OPERAND (arg, 0);
+	{
-	}
+	  tree idx = TREE_OPERAND (arg, 1);
-else if (TREE_CODE (TREE_OPERAND (arg, 0)) == VAR_DECL)
+	  if (TREE_CODE (idx) != INTEGER_CST)
-	{
-	  array = TREE_OPERAND (arg, 0);
-	  offset = size_zero_node;
-	}
-else if (TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF)
-	{
-	  array = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
-	  offset = TREE_OPERAND (TREE_OPERAND (arg, 0), 1);
-	  if (TREE_CODE (array) != STRING_CST && !VAR_P (array))
-	    return 0;
-	  /* Check if the array has a nonzero lower bound.  */
-	  lower_bound = array_ref_low_bound (TREE_OPERAND (arg, 0));
-	  if (!integer_zerop (lower_bound))
 	    {
-	      /* If the offset and base aren't both constants, return 0.  */
+	      /* From a pointer (but not array) argument extract the variable
-	      if (TREE_CODE (lower_bound) != INTEGER_CST)
+		 index to prevent get_addr_base_and_unit_offset() from failing
-	        return 0;
+		 due to it.  Use it later to compute the non-constant offset
-	      if (TREE_CODE (offset) != INTEGER_CST)
+		 into the string and return it to the caller.  */
-		return 0;
+	      varidx = idx;
-	      /* Adjust offset by the lower bound.  */
+	      ref = TREE_OPERAND (arg, 0);
-	      offset = size_diffop (fold_convert (sizetype, offset),
-				    fold_convert (sizetype, lower_bound));
+	      if (TREE_CODE (TREE_TYPE (arg)) == ARRAY_TYPE)
+		return NULL_TREE;
+	      if (!integer_zerop (array_ref_low_bound (arg)))
+		return NULL_TREE;
+	      if (!integer_onep (array_ref_element_size (arg)))
+		return NULL_TREE;
 	    }
 	}
-else if (TREE_CODE (TREE_OPERAND (arg, 0)) == MEM_REF)
+array = get_addr_base_and_unit_offset (ref, &base_off);
-	{
+if (!array
-	  array = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
+	  || (TREE_CODE (array) != VAR_DECL
-	  offset = TREE_OPERAND (TREE_OPERAND (arg, 0), 1);
+	      && TREE_CODE (array) != CONST_DECL
-	  if (TREE_CODE (array) != ADDR_EXPR)
+	      && TREE_CODE (array) != STRING_CST))
-	    return 0;
+	return NULL_TREE;
-	  array = TREE_OPERAND (array, 0);
-	  if (TREE_CODE (array) != STRING_CST && !VAR_P (array))
-	    return 0;
-	}
-else
-	return 0;
 }
 else if (TREE_CODE (arg) == PLUS_EXPR || TREE_CODE (arg) == POINTER_PLUS_EXPR)
 {
 tree arg0 = TREE_OPERAND (arg, 0);
 tree arg1 = TREE_OPERAND (arg, 1);
 STRIP_NOPS (arg0);
 STRIP_NOPS (arg1);
-if (TREE_CODE (arg0) == ADDR_EXPR
+if (TREE_CODE (arg0) == ADDR_EXPR)
-	  && (TREE_CODE (TREE_OPERAND (arg0, 0)) == STRING_CST
+	;   /* Do nothing.  */
-	      || TREE_CODE (TREE_OPERAND (arg0, 0)) == VAR_DECL))
+else if (TREE_CODE (arg1) == ADDR_EXPR)
-	{
+	std::swap (arg0, arg1);
-	  array = TREE_OPERAND (arg0, 0);
-	  offset = arg1;
-	}
-else if (TREE_CODE (arg1) == ADDR_EXPR
-	       && (TREE_CODE (TREE_OPERAND (arg1, 0)) == STRING_CST
-		   || TREE_CODE (TREE_OPERAND (arg1, 0)) == VAR_DECL))
-	{
-	  array = TREE_OPERAND (arg1, 0);
-	  offset = arg0;
-	}
 else
-	return 0;
+	return NULL_TREE;
-}
+tree offset;
+if (tree str = string_constant (arg0, &offset, mem_size, decl))
+	{
+	  /* Avoid pointers to arrays (see bug 86622).  */
+	  if (POINTER_TYPE_P (TREE_TYPE (arg))
+	      && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == ARRAY_TYPE
+	      && !(decl && !*decl)
+	      && !(decl && tree_fits_uhwi_p (DECL_SIZE_UNIT (*decl))
+		   && mem_size && tree_fits_uhwi_p (*mem_size)
+		   && tree_int_cst_equal (*mem_size, DECL_SIZE_UNIT (*decl))))
+	    return NULL_TREE;
+	  tree type = TREE_TYPE (arg1);
+	  *ptr_offset = fold_build2 (PLUS_EXPR, type, offset, arg1);
+	  return str;
+	}
+return NULL_TREE;
+}
+else if (TREE_CODE (arg) == SSA_NAME)
+{
+gimple *stmt = SSA_NAME_DEF_STMT (arg);
+if (!is_gimple_assign (stmt))
+	return NULL_TREE;
+tree rhs1 = gimple_assign_rhs1 (stmt);
+tree_code code = gimple_assign_rhs_code (stmt);
+if (code == ADDR_EXPR)
+	return string_constant (rhs1, ptr_offset, mem_size, decl);
+else if (code != POINTER_PLUS_EXPR)
+	return NULL_TREE;
+tree offset;
+if (tree str = string_constant (rhs1, &offset, mem_size, decl))
+	{
+	  /* Avoid pointers to arrays (see bug 86622).  */
+	  if (POINTER_TYPE_P (TREE_TYPE (rhs1))
+	      && TREE_CODE (TREE_TYPE (TREE_TYPE (rhs1))) == ARRAY_TYPE
+	      && !(decl && !*decl)
+	      && !(decl && tree_fits_uhwi_p (DECL_SIZE_UNIT (*decl))
+		   && mem_size && tree_fits_uhwi_p (*mem_size)
+		   && tree_int_cst_equal (*mem_size, DECL_SIZE_UNIT (*decl))))
+	    return NULL_TREE;
+	  tree rhs2 = gimple_assign_rhs2 (stmt);
+	  tree type = TREE_TYPE (rhs2);
+	  *ptr_offset = fold_build2 (PLUS_EXPR, type, offset, rhs2);
+	  return str;
+	}
+return NULL_TREE;
+}
+else if (DECL_P (arg))
+array = arg;
 else
-return 0;
+return NULL_TREE;
+tree offset = wide_int_to_tree (sizetype, base_off);
+if (varidx)
+{
+if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE)
+	return NULL_TREE;
+gcc_assert (TREE_CODE (arg) == ARRAY_REF);
+tree chartype = TREE_TYPE (TREE_TYPE (TREE_OPERAND (arg, 0)));
+if (TREE_CODE (chartype) != INTEGER_TYPE)
+	return NULL;
+offset = fold_convert (sizetype, varidx);
+}
 if (TREE_CODE (array) == STRING_CST)
 {
 *ptr_offset = fold_convert (sizetype, offset);
+if (mem_size)
+	*mem_size = TYPE_SIZE_UNIT (TREE_TYPE (array));
+if (decl)
+	*decl = NULL_TREE;
+gcc_checking_assert (tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (array)))
+			   >= TREE_STRING_LENGTH (array));
 return array;
 }
-else if (VAR_P (array) || TREE_CODE (array) == CONST_DECL)
-{
+if (!VAR_P (array) && TREE_CODE (array) != CONST_DECL)
-int length;
+return NULL_TREE;
-tree init = ctor_for_folding (array);
+tree init = ctor_for_folding (array);
-/* Variables initialized to string literals can be handled too.  */
-if (init == error_mark_node
+/* Handle variables initialized with string literals.  */
-	  || !init
+if (!init || init == error_mark_node)
-	  || TREE_CODE (init) != STRING_CST)
+return NULL_TREE;
-	return 0;
+if (TREE_CODE (init) == CONSTRUCTOR)
+{
-/* Avoid const char foo[4] = "abcde";  */
+/* Convert the 64-bit constant offset to a wider type to avoid
-if (DECL_SIZE_UNIT (array) == NULL_TREE
+	 overflow.  */
-	  || TREE_CODE (DECL_SIZE_UNIT (array)) != INTEGER_CST
+offset_int wioff;
-	  || (length = TREE_STRING_LENGTH (init)) <= 0
+if (!base_off.is_constant (&wioff))
-	  || compare_tree_int (DECL_SIZE_UNIT (array), length) < 0)
+	return NULL_TREE;
-	return 0;
+wioff *= BITS_PER_UNIT;
-/* If variable is bigger than the string literal, OFFSET must be constant
+if (!wi::fits_uhwi_p (wioff))
-	 and inside of the bounds of the string literal.  */
+	return NULL_TREE;
-offset = fold_convert (sizetype, offset);
-if (compare_tree_int (DECL_SIZE_UNIT (array), length) > 0
+base_off = wioff.to_uhwi ();
-	  && (! tree_fits_uhwi_p (offset)
+unsigned HOST_WIDE_INT fieldoff = 0;
-	      || compare_tree_int (offset, length) >= 0))
+init = fold_ctor_reference (NULL_TREE, init, base_off, 0, array,
-	return 0;
+				  &fieldoff);
+HOST_WIDE_INT cstoff;
-*ptr_offset = offset;
+if (!base_off.is_constant (&cstoff))
-return init;
+	return NULL_TREE;
-}
+cstoff = (cstoff - fieldoff) / BITS_PER_UNIT;
-return 0;
+tree off = build_int_cst (sizetype, cstoff);
+if (varidx)
+	offset = fold_build2 (PLUS_EXPR, TREE_TYPE (offset), offset, off);
+else
+	offset = off;
+}
+if (!init || TREE_CODE (init) != STRING_CST)
+return NULL_TREE;
+if (mem_size)
+*mem_size = TYPE_SIZE_UNIT (TREE_TYPE (init));
+if (decl)
+*decl = array;
+gcc_checking_assert (tree_to_shwi (TYPE_SIZE_UNIT (TREE_TYPE (init)))
+		       >= TREE_STRING_LENGTH (init));
+*ptr_offset = offset;
+return init;
+}
+/* Compute the modular multiplicative inverse of A modulo M
+using extended Euclid's algorithm.  Assumes A and M are coprime.  */
+static wide_int
+mod_inv (const wide_int &a, const wide_int &b)
+{
+/* Verify the assumption.  */
+gcc_checking_assert (wi::eq_p (wi::gcd (a, b), 1));
+unsigned int p = a.get_precision () + 1;
+gcc_checking_assert (b.get_precision () + 1 == p);
+wide_int c = wide_int::from (a, p, UNSIGNED);
+wide_int d = wide_int::from (b, p, UNSIGNED);
+wide_int x0 = wide_int::from (0, p, UNSIGNED);
+wide_int x1 = wide_int::from (1, p, UNSIGNED);
+if (wi::eq_p (b, 1))
+return wide_int::from (1, p, UNSIGNED);
+while (wi::gt_p (c, 1, UNSIGNED))
+{
+wide_int t = d;
+wide_int q = wi::divmod_trunc (c, d, UNSIGNED, &d);
+c = t;
+wide_int s = x0;
+x0 = wi::sub (x1, wi::mul (q, x0));
+x1 = s;
+}
+if (wi::lt_p (x1, 0, SIGNED))
+x1 += d;
+return x1;
+}
+/* Optimize x % C1 == C2 for signed modulo if C1 is a power of two and C2
+is non-zero and C3 ((1<<(prec-1)) | (C1 - 1)):
+for C2 > 0 to x & C3 == C2
+for C2 < 0 to x & C3 == (C2 & C3).  */
+enum tree_code
+maybe_optimize_pow2p_mod_cmp (enum tree_code code, tree *arg0, tree *arg1)
+{
+gimple *stmt = get_def_for_expr (*arg0, TRUNC_MOD_EXPR);
+tree treeop0 = gimple_assign_rhs1 (stmt);
+tree treeop1 = gimple_assign_rhs2 (stmt);
+tree type = TREE_TYPE (*arg0);
+scalar_int_mode mode;
+if (!is_a <scalar_int_mode> (TYPE_MODE (type), &mode))
+return code;
+if (GET_MODE_BITSIZE (mode) != TYPE_PRECISION (type)
+|| TYPE_PRECISION (type) <= 1
+|| TYPE_UNSIGNED (type)
+/* Signed x % c == 0 should have been optimized into unsigned modulo
+	 earlier.  */
+|| integer_zerop (*arg1)
+/* If c is known to be non-negative, modulo will be expanded as unsigned
+	 modulo.  */
+|| get_range_pos_neg (treeop0) == 1)
+return code;
+/* x % c == d where d < 0 && d <= -c should be always false.  */
+if (tree_int_cst_sgn (*arg1) == -1
+&& -wi::to_widest (treeop1) >= wi::to_widest (*arg1))
+return code;
+int prec = TYPE_PRECISION (type);
+wide_int w = wi::to_wide (treeop1) - 1;
+w |= wi::shifted_mask (0, prec - 1, true, prec);
+tree c3 = wide_int_to_tree (type, w);
+tree c4 = *arg1;
+if (tree_int_cst_sgn (*arg1) == -1)
+c4 = wide_int_to_tree (type, w & wi::to_wide (*arg1));
+rtx op0 = expand_normal (treeop0);
+treeop0 = make_tree (TREE_TYPE (treeop0), op0);
+bool speed_p = optimize_insn_for_speed_p ();
+do_pending_stack_adjust ();
+location_t loc = gimple_location (stmt);
+struct separate_ops ops;
+ops.code = TRUNC_MOD_EXPR;
+ops.location = loc;
+ops.type = TREE_TYPE (treeop0);
+ops.op0 = treeop0;
+ops.op1 = treeop1;
+ops.op2 = NULL_TREE;
+start_sequence ();
+rtx mor = expand_expr_real_2 (&ops, NULL_RTX, TYPE_MODE (ops.type),
+				EXPAND_NORMAL);
+rtx_insn *moinsns = get_insns ();
+end_sequence ();
+unsigned mocost = seq_cost (moinsns, speed_p);
+mocost += rtx_cost (mor, mode, EQ, 0, speed_p);
+mocost += rtx_cost (expand_normal (*arg1), mode, EQ, 1, speed_p);
+ops.code = BIT_AND_EXPR;
+ops.location = loc;
+ops.type = TREE_TYPE (treeop0);
+ops.op0 = treeop0;
+ops.op1 = c3;
+ops.op2 = NULL_TREE;
+start_sequence ();
+rtx mur = expand_expr_real_2 (&ops, NULL_RTX, TYPE_MODE (ops.type),
+				EXPAND_NORMAL);
+rtx_insn *muinsns = get_insns ();
+end_sequence ();
+unsigned mucost = seq_cost (muinsns, speed_p);
+mucost += rtx_cost (mur, mode, EQ, 0, speed_p);
+mucost += rtx_cost (expand_normal (c4), mode, EQ, 1, speed_p);
+if (mocost <= mucost)
+{
+emit_insn (moinsns);
+*arg0 = make_tree (TREE_TYPE (*arg0), mor);
+return code;
+}
+emit_insn (muinsns);
+*arg0 = make_tree (TREE_TYPE (*arg0), mur);
+*arg1 = c4;
+return code;
+}
+/* Attempt to optimize unsigned (X % C1) == C2 (or (X % C1) != C2).
+If C1 is odd to:
+(X - C2) * C3 <= C4 (or >), where
+C3 is modular multiplicative inverse of C1 and 1<<prec and
+C4 is ((1<<prec) - 1) / C1 or ((1<<prec) - 1) / C1 - 1 (the latter
+if C2 > ((1<<prec) - 1) % C1).
+If C1 is even, S = ctz (C1) and C2 is 0, use
+((X * C3) r>> S) <= C4, where C3 is modular multiplicative
+inverse of C1>>S and 1<<prec and C4 is (((1<<prec) - 1) / (C1>>S)) >> S.
+For signed (X % C1) == 0 if C1 is odd to (all operations in it
+unsigned):
+(X * C3) + C4 <= 2 * C4, where
+C3 is modular multiplicative inverse of (unsigned) C1 and 1<<prec and
+C4 is ((1<<(prec - 1) - 1) / C1).
+If C1 is even, S = ctz(C1), use
+((X * C3) + C4) r>> S <= (C4 >> (S - 1))
+where C3 is modular multiplicative inverse of (unsigned)(C1>>S) and 1<<prec
+and C4 is ((1<<(prec - 1) - 1) / (C1>>S)) & (-1<<S).
+See the Hacker's Delight book, section 10-17.  */
+enum tree_code
+maybe_optimize_mod_cmp (enum tree_code code, tree *arg0, tree *arg1)
+{
+gcc_checking_assert (code == EQ_EXPR || code == NE_EXPR);
+gcc_checking_assert (TREE_CODE (*arg1) == INTEGER_CST);
+if (optimize < 2)
+return code;
+gimple *stmt = get_def_for_expr (*arg0, TRUNC_MOD_EXPR);
+if (stmt == NULL)
+return code;
+tree treeop0 = gimple_assign_rhs1 (stmt);
+tree treeop1 = gimple_assign_rhs2 (stmt);
+if (TREE_CODE (treeop0) != SSA_NAME
+|| TREE_CODE (treeop1) != INTEGER_CST
+/* Don't optimize the undefined behavior case x % 0;
+	 x % 1 should have been optimized into zero, punt if
+	 it makes it here for whatever reason;
+	 x % -c should have been optimized into x % c.  */
+|| compare_tree_int (treeop1, 2) <= 0
+/* Likewise x % c == d where d >= c should be always false.  */
+|| tree_int_cst_le (treeop1, *arg1))
+return code;
+/* Unsigned x % pow2 is handled right already, for signed
+modulo handle it in maybe_optimize_pow2p_mod_cmp.  */
+if (integer_pow2p (treeop1))
+return maybe_optimize_pow2p_mod_cmp (code, arg0, arg1);
+tree type = TREE_TYPE (*arg0);
+scalar_int_mode mode;
+if (!is_a <scalar_int_mode> (TYPE_MODE (type), &mode))
+return code;
+if (GET_MODE_BITSIZE (mode) != TYPE_PRECISION (type)
+|| TYPE_PRECISION (type) <= 1)
+return code;
+signop sgn = UNSIGNED;
+/* If both operands are known to have the sign bit clear, handle
+even the signed modulo case as unsigned.  treeop1 is always
+positive >= 2, checked above.  */
+if (!TYPE_UNSIGNED (type) && get_range_pos_neg (treeop0) != 1)
+sgn = SIGNED;
+if (!TYPE_UNSIGNED (type))
+{
+if (tree_int_cst_sgn (*arg1) == -1)
+	return code;
+type = unsigned_type_for (type);
+if (!type || TYPE_MODE (type) != TYPE_MODE (TREE_TYPE (*arg0)))
+	return code;
+}
+int prec = TYPE_PRECISION (type);
+wide_int w = wi::to_wide (treeop1);
+int shift = wi::ctz (w);
+/* Unsigned (X % C1) == C2 is equivalent to (X - C2) % C1 == 0 if
+C2 <= -1U % C1, because for any Z >= 0U - C2 in that case (Z % C1) != 0.
+If C1 is odd, we can handle all cases by subtracting
+C4 below.  We could handle even the even C1 and C2 > -1U % C1 cases
+e.g. by testing for overflow on the subtraction, punt on that for now
+though.  */
+if ((sgn == SIGNED || shift) && !integer_zerop (*arg1))
+{
+if (sgn == SIGNED)
+	return code;
+wide_int x = wi::umod_trunc (wi::mask (prec, false, prec), w);
+if (wi::gtu_p (wi::to_wide (*arg1), x))
+	return code;
+}
+imm_use_iterator imm_iter;
+use_operand_p use_p;
+FOR_EACH_IMM_USE_FAST (use_p, imm_iter, treeop0)
+{
+gimple *use_stmt = USE_STMT (use_p);
+/* Punt if treeop0 is used in the same bb in a division
+	 or another modulo with the same divisor.  We should expect
+	 the division and modulo combined together.  */
+if (use_stmt == stmt
+	  || gimple_bb (use_stmt) != gimple_bb (stmt))
+	continue;
+if (!is_gimple_assign (use_stmt)
+	  || (gimple_assign_rhs_code (use_stmt) != TRUNC_DIV_EXPR
+	      && gimple_assign_rhs_code (use_stmt) != TRUNC_MOD_EXPR))
+	continue;
+if (gimple_assign_rhs1 (use_stmt) != treeop0
+	  || !operand_equal_p (gimple_assign_rhs2 (use_stmt), treeop1, 0))
+	continue;
+return code;
+}
+w = wi::lrshift (w, shift);
+wide_int a = wide_int::from (w, prec + 1, UNSIGNED);
+wide_int b = wi::shifted_mask (prec, 1, false, prec + 1);
+wide_int m = wide_int::from (mod_inv (a, b), prec, UNSIGNED);
+tree c3 = wide_int_to_tree (type, m);
+tree c5 = NULL_TREE;
+wide_int d, e;
+if (sgn == UNSIGNED)
+{
+d = wi::divmod_trunc (wi::mask (prec, false, prec), w, UNSIGNED, &e);
+/* Use <= floor ((1<<prec) - 1) / C1 only if C2 <= ((1<<prec) - 1) % C1,
+	 otherwise use < or subtract one from C4.  E.g. for
+	 x % 3U == 0 we transform this into x * 0xaaaaaaab <= 0x55555555, but
+	 x % 3U == 1 already needs to be
+	 (x - 1) * 0xaaaaaaabU <= 0x55555554.  */
+if (!shift && wi::gtu_p (wi::to_wide (*arg1), e))
+	d -= 1;
+if (shift)
+	d = wi::lrshift (d, shift);
+}
+else
+{
+e = wi::udiv_trunc (wi::mask (prec - 1, false, prec), w);
+if (!shift)
+	d = wi::lshift (e, 1);
+else
+	{
+	  e = wi::bit_and (e, wi::mask (shift, true, prec));
+	  d = wi::lrshift (e, shift - 1);
+	}
+c5 = wide_int_to_tree (type, e);
+}
+tree c4 = wide_int_to_tree (type, d);
+rtx op0 = expand_normal (treeop0);
+treeop0 = make_tree (TREE_TYPE (treeop0), op0);
+bool speed_p = optimize_insn_for_speed_p ();
+do_pending_stack_adjust ();
+location_t loc = gimple_location (stmt);
+struct separate_ops ops;
+ops.code = TRUNC_MOD_EXPR;
+ops.location = loc;
+ops.type = TREE_TYPE (treeop0);
+ops.op0 = treeop0;
+ops.op1 = treeop1;
+ops.op2 = NULL_TREE;
+start_sequence ();
+rtx mor = expand_expr_real_2 (&ops, NULL_RTX, TYPE_MODE (ops.type),
+				EXPAND_NORMAL);
+rtx_insn *moinsns = get_insns ();
+end_sequence ();
+unsigned mocost = seq_cost (moinsns, speed_p);
+mocost += rtx_cost (mor, mode, EQ, 0, speed_p);
+mocost += rtx_cost (expand_normal (*arg1), mode, EQ, 1, speed_p);
+tree t = fold_convert_loc (loc, type, treeop0);
+if (!integer_zerop (*arg1))
+t = fold_build2_loc (loc, MINUS_EXPR, type, t, fold_convert (type, *arg1));
+t = fold_build2_loc (loc, MULT_EXPR, type, t, c3);
+if (sgn == SIGNED)
+t = fold_build2_loc (loc, PLUS_EXPR, type, t, c5);
+if (shift)
+{
+tree s = build_int_cst (NULL_TREE, shift);
+t = fold_build2_loc (loc, RROTATE_EXPR, type, t, s);
+}
+start_sequence ();
+rtx mur = expand_normal (t);
+rtx_insn *muinsns = get_insns ();
+end_sequence ();
+unsigned mucost = seq_cost (muinsns, speed_p);
+mucost += rtx_cost (mur, mode, LE, 0, speed_p);
+mucost += rtx_cost (expand_normal (c4), mode, LE, 1, speed_p);
+if (mocost <= mucost)
+{
+emit_insn (moinsns);
+*arg0 = make_tree (TREE_TYPE (*arg0), mor);
+return code;
+}
+emit_insn (muinsns);
+*arg0 = make_tree (type, mur);
+*arg1 = c4;
+return code == EQ_EXPR ? LE_EXPR : GT_EXPR;
 }
 /* Generate code to calculate OPS, and exploded expression
 using a store-flag instruction and return an rtx for the result.
 OPS reflects a comparison.
 return 0;
 /* We won't bother with store-flag operations involving function pointers
 when function pointers must be canonicalized before comparisons.  */
 if (targetm.have_canonicalize_funcptr_for_compare ()
-&& ((TREE_CODE (TREE_TYPE (arg0)) == POINTER_TYPE
+&& ((POINTER_TYPE_P (TREE_TYPE (arg0))
-	   && (TREE_CODE (TREE_TYPE (TREE_TYPE (arg0)))
+	   && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (arg0))))
-	       == FUNCTION_TYPE))
+	  || (POINTER_TYPE_P (TREE_TYPE (arg1))
-	  || (TREE_CODE (TREE_TYPE (arg1)) == POINTER_TYPE
+	      && FUNC_OR_METHOD_TYPE_P (TREE_TYPE (TREE_TYPE (arg1))))))
-	      && (TREE_CODE (TREE_TYPE (TREE_TYPE (arg1)))
-		  == FUNCTION_TYPE))))
 return 0;
 STRIP_NOPS (arg0);
 STRIP_NOPS (arg1);
 /* For vector typed comparisons emit code to generate the desired
 all-ones or all-zeros mask.  Conveniently use the VEC_COND_EXPR
 expander for this.  */
 if (TREE_CODE (ops->type) == VECTOR_TYPE)
 {
 	{
 	  tree if_true = constant_boolean_node (true, ops->type);
 	  tree if_false = constant_boolean_node (false, ops->type);
 	  return expand_vec_cond_expr (ops->type, ifexp, if_true,
 				       if_false, target);
+	}
+}
+/* Optimize (x % C1) == C2 or (x % C1) != C2 if it is beneficial
+into (x - C2) * C3 < C4.  */
+if ((ops->code == EQ_EXPR || ops->code == NE_EXPR)
+&& TREE_CODE (arg0) == SSA_NAME
+&& TREE_CODE (arg1) == INTEGER_CST)
+{
+enum tree_code code = maybe_optimize_mod_cmp (ops->code, &arg0, &arg1);
+if (code != ops->code)
+	{
+	  struct separate_ops nops = *ops;
+	  nops.code = ops->code = code;
+	  nops.op0 = arg0;
+	  nops.op1 = arg1;
+	  nops.type = TREE_TYPE (arg0);
+	  return do_store_flag (&nops, target, mode);
 	}
 }
 /* Get the rtx comparison code to use.  We know that EXP is a comparison
 operation of some type.  Some comparisons against 1 and -1 can be
 if (default_label)
 emit_cmp_and_jump_insns (index, range, GTU, NULL_RTX, mode, 1,
 			     default_label, default_probability);
 /* If index is in range, it must fit in Pmode.
 Convert to Pmode so we can index with it.  */
 if (mode != Pmode)
-index = convert_to_mode (Pmode, index, 1);
+{
+unsigned int width;
+/* We know the value of INDEX is between 0 and RANGE.  If we have a
+	 sign-extended subreg, and RANGE does not have the sign bit set, then
+	 we have a value that is valid for both sign and zero extension.  In
+	 this case, we get better code if we sign extend.  */
+if (GET_CODE (index) == SUBREG
+	  && SUBREG_PROMOTED_VAR_P (index)
+	  && SUBREG_PROMOTED_SIGNED_P (index)
+	  && ((width = GET_MODE_PRECISION (as_a <scalar_int_mode> (mode)))
+	      <= HOST_BITS_PER_WIDE_INT)
+	  && ! (UINTVAL (range) & (HOST_WIDE_INT_1U << (width - 1))))
+	index = convert_to_mode (Pmode, index, 0);
+else
+	index = convert_to_mode (Pmode, index, 1);
+}
 /* Don't let a MEM slip through, because then INDEX that comes
 out of PIC_CASE_VECTOR_ADDRESS won't be a valid address,
 and break_out_memory_refs will go to work on it and mess it up.  */
 #ifdef PIC_CASE_VECTOR_ADDRESS
 /* Return a CONST_VECTOR rtx representing vector mask for
 a VECTOR_CST of booleans.  */
 static rtx
 const_vector_mask_from_tree (tree exp)
 {
-rtvec v;
+machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
-unsigned i, units;
+machine_mode inner = GET_MODE_INNER (mode);
-tree elt;
-machine_mode inner, mode;
+rtx_vector_builder builder (mode, VECTOR_CST_NPATTERNS (exp),
+			      VECTOR_CST_NELTS_PER_PATTERN (exp));
-mode = TYPE_MODE (TREE_TYPE (exp));
+unsigned int count = builder.encoded_nelts ();
-units = VECTOR_CST_NELTS (exp);
+for (unsigned int i = 0; i < count; ++i)
-inner = GET_MODE_INNER (mode);
+{
+tree elt = VECTOR_CST_ELT (exp, i);
-v = rtvec_alloc (units);
-for (i = 0; i < units; ++i)
-{
-elt = VECTOR_CST_ELT (exp, i);
 gcc_assert (TREE_CODE (elt) == INTEGER_CST);
 if (integer_zerop (elt))
-	RTVEC_ELT (v, i) = CONST0_RTX (inner);
+	builder.quick_push (CONST0_RTX (inner));
 else if (integer_onep (elt)
 	       || integer_minus_onep (elt))
-	RTVEC_ELT (v, i) = CONSTM1_RTX (inner);
+	builder.quick_push (CONSTM1_RTX (inner));
 else
 	gcc_unreachable ();
 }
+return builder.build ();
-return gen_rtx_CONST_VECTOR (mode, v);
 }
 /* EXP is a VECTOR_CST in which each element is either all-zeros or all-ones.
 Return a constant scalar rtx of mode MODE in which bit X is set if element
 X of EXP is nonzero.  */
 static rtx
 const_scalar_mask_from_tree (scalar_int_mode mode, tree exp)
 {
 wide_int res = wi::zero (GET_MODE_PRECISION (mode));
 tree elt;
-unsigned i;
+/* The result has a fixed number of bits so the input must too.  */
-for (i = 0; i < VECTOR_CST_NELTS (exp); ++i)
+unsigned int nunits = VECTOR_CST_NELTS (exp).to_constant ();
+for (unsigned int i = 0; i < nunits; ++i)
 {
 elt = VECTOR_CST_ELT (exp, i);
 gcc_assert (TREE_CODE (elt) == INTEGER_CST);
 if (integer_all_onesp (elt))
 	res = wi::set_bit (res, i);
 /* Return a CONST_VECTOR rtx for a VECTOR_CST tree.  */
 static rtx
 const_vector_from_tree (tree exp)
 {
-rtvec v;
+machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
-unsigned i, units;
-tree elt;
-machine_mode inner, mode;
-mode = TYPE_MODE (TREE_TYPE (exp));
 if (initializer_zerop (exp))
 return CONST0_RTX (mode);
 if (VECTOR_BOOLEAN_TYPE_P (TREE_TYPE (exp)))
 return const_vector_mask_from_tree (exp);
-units = VECTOR_CST_NELTS (exp);
+machine_mode inner = GET_MODE_INNER (mode);
-inner = GET_MODE_INNER (mode);
+rtx_vector_builder builder (mode, VECTOR_CST_NPATTERNS (exp),
-v = rtvec_alloc (units);
+			      VECTOR_CST_NELTS_PER_PATTERN (exp));
+unsigned int count = builder.encoded_nelts ();
-for (i = 0; i < units; ++i)
+for (unsigned int i = 0; i < count; ++i)
 {
-elt = VECTOR_CST_ELT (exp, i);
+tree elt = VECTOR_CST_ELT (exp, i);
 if (TREE_CODE (elt) == REAL_CST)
-	RTVEC_ELT (v, i) = const_double_from_real_value (TREE_REAL_CST (elt),
+	builder.quick_push (const_double_from_real_value (TREE_REAL_CST (elt),
-							 inner);
+							  inner));
 else if (TREE_CODE (elt) == FIXED_CST)
-	RTVEC_ELT (v, i) = CONST_FIXED_FROM_FIXED_VALUE (TREE_FIXED_CST (elt),
+	builder.quick_push (CONST_FIXED_FROM_FIXED_VALUE (TREE_FIXED_CST (elt),
-							 inner);
+							  inner));
 else
-	RTVEC_ELT (v, i) = immed_wide_int_const (wi::to_wide (elt), inner);
+	builder.quick_push (immed_wide_int_const (wi::to_poly_wide (elt),
-}
+						  inner));
+}
-return gen_rtx_CONST_VECTOR (mode, v);
+return builder.build ();
 }
 /* Build a decl for a personality function given a language prefix.  */
 tree

Mercurial > hg > CbC > CbC_gcc

comparison gcc/expr.c @ 131:84e7813d76e9