CbC/CbC_gcc: gcc/gimple-fold.c comparison

comparison gcc/gimple-fold.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
 /* Statement simplification on GIMPLE.
-Copyright (C) 2010-2017 Free Software Foundation, Inc.
+Copyright (C) 2010-2018 Free Software Foundation, Inc.
 Split out from tree-ssa-ccp.c.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it
 #include "gimple.h"
 #include "predict.h"
 #include "ssa.h"
 #include "cgraph.h"
 #include "gimple-pretty-print.h"
+#include "gimple-ssa-warn-restrict.h"
 #include "fold-const.h"
 #include "stmt.h"
 #include "expr.h"
 #include "stor-layout.h"
 #include "dumpfile.h"
 #include "gimple-fold.h"
 #include "gimplify.h"
 #include "gimple-iterator.h"
 #include "tree-into-ssa.h"
 #include "tree-dfa.h"
+#include "tree-object-size.h"
 #include "tree-ssa.h"
 #include "tree-ssa-propagate.h"
 #include "ipa-utils.h"
 #include "tree-ssa-address.h"
 #include "langhooks.h"
 #include "tree-eh.h"
 #include "gimple-match.h"
 #include "gomp-constants.h"
 #include "optabs-query.h"
 #include "omp-general.h"
-#include "ipa-chkp.h"
 #include "tree-cfg.h"
 #include "fold-const-call.h"
 #include "stringpool.h"
 #include "attribs.h"
 #include "asan.h"
+#include "diagnostic-core.h"
+#include "intl.h"
+#include "calls.h"
+#include "tree-vector-builder.h"
+#include "tree-ssa-strlen.h"
 /* Return true when DECL can be referenced from current unit.
 FROM_DECL (if non-null) specify constructor of variable DECL was taken from.
 We can get declarations that are not possible to reference for various
 reasons:
 		  = possible_polymorphic_call_targets (rhs, stmt, &final);
 		if (final && targets.length () <= 1 && dbg_cnt (devirt))
 		  {
 		    if (dump_enabled_p ())
 		      {
-			location_t loc = gimple_location_safe (stmt);
+			dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
-			dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc,
 					 "resolving virtual function address "
 					 "reference to function %s\n",
 					 targets.length () == 1
 					 ? targets[0]->name ()
 					 : "NULL");
 var_decl_component_p (tree var)
 {
 tree inner = var;
 while (handled_component_p (inner))
 inner = TREE_OPERAND (inner, 0);
-return SSA_VAR_P (inner);
+return (DECL_P (inner)
+	  || (TREE_CODE (inner) == MEM_REF
+	      && TREE_CODE (TREE_OPERAND (inner, 0)) == ADDR_EXPR));
 }
 /* If the SIZE argument representing the size of an object is in a range
 of values of which exactly one is valid (and that is zero), return
 true, otherwise false.  */
 size_must_be_zero_p (tree size)
 {
 if (integer_zerop (size))
 return true;
-if (TREE_CODE (size) != SSA_NAME)
+if (TREE_CODE (size) != SSA_NAME || !INTEGRAL_TYPE_P (TREE_TYPE (size)))
 return false;
 wide_int min, max;
-enum value_range_type rtype = get_range_info (size, &min, &max);
+enum value_range_kind rtype = get_range_info (size, &min, &max);
 if (rtype != VR_ANTI_RANGE)
 return false;
 tree type = TREE_TYPE (size);
 int prec = TYPE_PRECISION (type);
 wide_int ssize_max = wi::lshift (wi::one (prec), prec - 1) - 1;
 return wi::eq_p (min, wone) && wi::geu_p (max, ssize_max);
 }
-/* Fold function call to builtin mem{{,p}cpy,move}.  Return
+/* Fold function call to builtin mem{{,p}cpy,move}.  Try to detect and
-false if no simplification can be made.
+diagnose (otherwise undefined) overlapping copies without preventing
-If ENDP is 0, return DEST (like memcpy).
+folding.  When folded, GCC guarantees that overlapping memcpy has
-If ENDP is 1, return DEST+LEN (like mempcpy).
+the same semantics as memmove.  Call to the library memcpy need not
-If ENDP is 2, return DEST+LEN-1 (like stpcpy).
+provide the same guarantee.  Return false if no simplification can
-If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
+be made.  */
-(memmove).   */
 static bool
 gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
 			       tree dest, tree src, int endp)
 {
 gimple *stmt = gsi_stmt (*gsi);
 tree lhs = gimple_call_lhs (stmt);
 tree len = gimple_call_arg (stmt, 2);
 tree destvar, srcvar;
 location_t loc = gimple_location (stmt);
+bool nowarn = gimple_no_warning_p (stmt);
 /* If the LEN parameter is a constant zero or in range where
 the only valid value is zero, return DEST.  */
 if (size_must_be_zero_p (len))
 {
 /* If SRC and DEST are the same (and not volatile), return
 DEST{,+LEN,+LEN-1}.  */
 if (operand_equal_p (src, dest, 0))
 {
+/* Avoid diagnosing exact overlap in calls to __builtin_memcpy.
+	 It's safe and may even be emitted by GCC itself (see bug
+	 32667).  */
 unlink_stmt_vdef (stmt);
 if (gimple_vdef (stmt) && TREE_CODE (gimple_vdef (stmt)) == SSA_NAME)
 	release_ssa_name (gimple_vdef (stmt));
 if (!lhs)
 	{
 else
 {
 tree srctype, desttype;
 unsigned int src_align, dest_align;
 tree off0;
+const char *tmp_str;
-/* Inlining of memcpy/memmove may cause bounds lost (if we copy
+unsigned HOST_WIDE_INT tmp_len;
-	 pointers as wide integer) and also may result in huge function
-	 size because of inlined bounds copy.  Thus don't inline for
-	 functions we want to instrument.  */
-if (flag_check_pointer_bounds
-	  && chkp_instrumentable_p (cfun->decl)
-	  /* Even if data may contain pointers we can inline if copy
-	     less than a pointer size.  */
-	  && (!tree_fits_uhwi_p (len)
-	      || compare_tree_int (len, POINTER_SIZE_UNITS) >= 0))
-	return false;
 /* Build accesses at offset zero with a ref-all character type.  */
 off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
 							 ptr_mode, true), 0);
 	  && compare_tree_int (len, MOVE_MAX) <= 0
 	  /* ???  Don't transform copies from strings with known length this
 	     confuses the tree-ssa-strlen.c.  This doesn't handle
 	     the case in gcc.dg/strlenopt-8.c which is XFAILed for that
 	     reason.  */
-	  && !c_strlen (src, 2))
+	  && !c_strlen (src, 2)
+	  && !((tmp_str = c_getstr (src, &tmp_len)) != NULL
+	       && memchr (tmp_str, 0, tmp_len) == NULL))
 	{
 	  unsigned ilen = tree_to_uhwi (len);
 	  if (pow2p_hwi (ilen))
 	    {
+	      /* Detect invalid bounds and overlapping copies and issue
+		 either -Warray-bounds or -Wrestrict.  */
+	      if (!nowarn
+		  && check_bounds_or_overlap (as_a <gcall *>(stmt),
+					      dest, src, len, len))
+	      	gimple_set_no_warning (stmt, true);
 	      scalar_int_mode mode;
 	      tree type = lang_hooks.types.type_for_size (ilen * 8, 1);
 	      if (type
 		  && is_a <scalar_int_mode> (TYPE_MODE (type), &mode)
 		  && GET_MODE_SIZE (mode) * BITS_PER_UNIT == ilen * 8
 	  /* If *src and *dest can't overlap, optimize into memcpy as well.  */
 	  if (TREE_CODE (src) == ADDR_EXPR
 	      && TREE_CODE (dest) == ADDR_EXPR)
 	    {
 	      tree src_base, dest_base, fn;
-	      HOST_WIDE_INT src_offset = 0, dest_offset = 0;
+	      poly_int64 src_offset = 0, dest_offset = 0;
-	      HOST_WIDE_INT maxsize;
+	      poly_uint64 maxsize;
 	      srcvar = TREE_OPERAND (src, 0);
 	      src_base = get_addr_base_and_unit_offset (srcvar, &src_offset);
 	      if (src_base == NULL)
 		src_base = srcvar;
 	      destvar = TREE_OPERAND (dest, 0);
 	      dest_base = get_addr_base_and_unit_offset (destvar,
 							 &dest_offset);
 	      if (dest_base == NULL)
 		dest_base = destvar;
-	      if (tree_fits_uhwi_p (len))
+	      if (!poly_int_tree_p (len, &maxsize))
-		maxsize = tree_to_uhwi (len);
-	      else
 		maxsize = -1;
 	      if (SSA_VAR_P (src_base)
 		  && SSA_VAR_P (dest_base))
 		{
 		  if (operand_equal_p (src_base, dest_base, 0)
-		      && ranges_overlap_p (src_offset, maxsize,
+		      && ranges_maybe_overlap_p (src_offset, maxsize,
-					   dest_offset, maxsize))
+						 dest_offset, maxsize))
 		    return false;
 		}
 	      else if (TREE_CODE (src_base) == MEM_REF
 		       && TREE_CODE (dest_base) == MEM_REF)
 		{
 		  if (! operand_equal_p (TREE_OPERAND (src_base, 0),
 					 TREE_OPERAND (dest_base, 0), 0))
 		    return false;
-		  offset_int off = mem_ref_offset (src_base) + src_offset;
+		  poly_offset_int full_src_offset
-		  if (!wi::fits_shwi_p (off))
+		    = mem_ref_offset (src_base) + src_offset;
-		    return false;
+		  poly_offset_int full_dest_offset
-		  src_offset = off.to_shwi ();
+		    = mem_ref_offset (dest_base) + dest_offset;
+		  if (ranges_maybe_overlap_p (full_src_offset, maxsize,
-		  off = mem_ref_offset (dest_base) + dest_offset;
+					      full_dest_offset, maxsize))
-		  if (!wi::fits_shwi_p (off))
-		    return false;
-		  dest_offset = off.to_shwi ();
-		  if (ranges_overlap_p (src_offset, maxsize,
-					dest_offset, maxsize))
 		    return false;
 		}
 	      else
 		return false;
 	  return false;
 	}
 if (!tree_fits_shwi_p (len))
 	return false;
-/* FIXME:
-This logic lose for arguments like (type *)malloc (sizeof (type)),
-since we strip the casts of up to VOID return value from malloc.
-	 Perhaps we ought to inherit type from non-VOID argument here?  */
-STRIP_NOPS (src);
-STRIP_NOPS (dest);
 if (!POINTER_TYPE_P (TREE_TYPE (src))
 	  || !POINTER_TYPE_P (TREE_TYPE (dest)))
 	return false;
 /* In the following try to find a type that is most natural to be
 	 used for the memcpy source and destination and that allows
 	 the most optimization when memcpy is turned into a plain assignment
 	 using that type.  In theory we could always use a char[len] type
 	 but that only gains us that the destination and source possibly
 	 no longer will have their address taken.  */
-/* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
-if (TREE_CODE (src) == POINTER_PLUS_EXPR)
-	{
-	  tree tem = TREE_OPERAND (src, 0);
-	  STRIP_NOPS (tem);
-	  if (tem != TREE_OPERAND (src, 0))
-	    src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
-	}
-if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
-	{
-	  tree tem = TREE_OPERAND (dest, 0);
-	  STRIP_NOPS (tem);
-	  if (tem != TREE_OPERAND (dest, 0))
-	    dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
-	}
 srctype = TREE_TYPE (TREE_TYPE (src));
 if (TREE_CODE (srctype) == ARRAY_TYPE
 	  && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
-	{
+	srctype = TREE_TYPE (srctype);
-	  srctype = TREE_TYPE (srctype);
-	  STRIP_NOPS (src);
-	  src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
-	}
 desttype = TREE_TYPE (TREE_TYPE (dest));
 if (TREE_CODE (desttype) == ARRAY_TYPE
 	  && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
-	{
+	desttype = TREE_TYPE (desttype);
-	  desttype = TREE_TYPE (desttype);
-	  STRIP_NOPS (dest);
-	  dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
-	}
 if (TREE_ADDRESSABLE (srctype)
 	  || TREE_ADDRESSABLE (desttype))
 	return false;
 /* Make sure we are not copying using a floating-point mode or
 dest_align = get_pointer_alignment (dest);
 if (dest_align < TYPE_ALIGN (desttype)
 	  || src_align < TYPE_ALIGN (srctype))
 	return false;
-destvar = dest;
+destvar = NULL_TREE;
-STRIP_NOPS (destvar);
+if (TREE_CODE (dest) == ADDR_EXPR
-if (TREE_CODE (destvar) == ADDR_EXPR
+	  && var_decl_component_p (TREE_OPERAND (dest, 0))
-	  && var_decl_component_p (TREE_OPERAND (destvar, 0))
 	  && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
-	destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
+	destvar = fold_build2 (MEM_REF, desttype, dest, off0);
-else
-	destvar = NULL_TREE;
+srcvar = NULL_TREE;
+if (TREE_CODE (src) == ADDR_EXPR
-srcvar = src;
+	  && var_decl_component_p (TREE_OPERAND (src, 0))
-STRIP_NOPS (srcvar);
-if (TREE_CODE (srcvar) == ADDR_EXPR
-	  && var_decl_component_p (TREE_OPERAND (srcvar, 0))
 	  && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
 	{
 	  if (!destvar
 	      || src_align >= TYPE_ALIGN (desttype))
 	    srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
-				  srcvar, off0);
+				  src, off0);
 	  else if (!STRICT_ALIGNMENT)
 	    {
 	      srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
 					    src_align);
-	      srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
+	      srcvar = fold_build2 (MEM_REF, srctype, src, off0);
 	    }
-	  else
+	}
-	    srcvar = NULL_TREE;
-	}
-else
-	srcvar = NULL_TREE;
 if (srcvar == NULL_TREE && destvar == NULL_TREE)
 	return false;
 if (srcvar == NULL_TREE)
 	{
-	  STRIP_NOPS (src);
 	  if (src_align >= TYPE_ALIGN (desttype))
 	    srcvar = fold_build2 (MEM_REF, desttype, src, off0);
 	  else
 	    {
 	      if (STRICT_ALIGNMENT)
 	      srcvar = fold_build2 (MEM_REF, srctype, src, off0);
 	    }
 	}
 else if (destvar == NULL_TREE)
 	{
-	  STRIP_NOPS (dest);
 	  if (dest_align >= TYPE_ALIGN (srctype))
 	    destvar = fold_build2 (MEM_REF, srctype, dest, off0);
 	  else
 	    {
 	      if (STRICT_ALIGNMENT)
 	      desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
 					     dest_align);
 	      destvar = fold_build2 (MEM_REF, desttype, dest, off0);
 	    }
 	}
+/* Detect invalid bounds and overlapping copies and issue either
+	 -Warray-bounds or -Wrestrict.  */
+if (!nowarn)
+	check_bounds_or_overlap (as_a <gcall *>(stmt), dest, src, len, len);
 gimple *new_stmt;
 if (is_gimple_reg_type (TREE_TYPE (srcvar)))
 	{
 	  tree tem = fold_const_aggregate_ref (srcvar);
 						   new_stmt);
 	      gimple_assign_set_lhs (new_stmt, srcvar);
 	      gimple_set_vuse (new_stmt, gimple_vuse (stmt));
 	      gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
 	    }
-	}
+	  new_stmt = gimple_build_assign (destvar, srcvar);
-new_stmt = gimple_build_assign (destvar, srcvar);
+	  goto set_vop_and_replace;
+	}
+/* We get an aggregate copy.  Use an unsigned char[] type to
+	 perform the copying to preserve padding and to avoid any issues
+	 with TREE_ADDRESSABLE types or float modes behavior on copying.  */
+desttype = build_array_type_nelts (unsigned_char_type_node,
+					 tree_to_uhwi (len));
+srctype = desttype;
+if (src_align > TYPE_ALIGN (srctype))
+	srctype = build_aligned_type (srctype, src_align);
+if (dest_align > TYPE_ALIGN (desttype))
+	desttype = build_aligned_type (desttype, dest_align);
+new_stmt
+	= gimple_build_assign (fold_build2 (MEM_REF, desttype, dest, off0),
+			       fold_build2 (MEM_REF, srctype, src, off0));
+set_vop_and_replace:
 gimple_set_vuse (new_stmt, gimple_vuse (stmt));
 gimple_set_vdef (new_stmt, gimple_vdef (stmt));
 if (gimple_vdef (new_stmt)
 	  && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
 	SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
 /* Obtain the minimum and maximum string length or minimum and maximum
 value of ARG in LENGTH[0] and LENGTH[1], respectively.
 If ARG is an SSA name variable, follow its use-def chains.  When
 TYPE == 0, if LENGTH[1] is not equal to the length we determine or
-if we are unable to determine the length or value, return False.
+if we are unable to determine the length or value, return false.
 VISITED is a bitmap of visited variables.
 TYPE is 0 if string length should be obtained, 1 for maximum string
 length and 2 for maximum value ARG can have.
-When FUZZY is set and the length of a string cannot be determined,
+When FUZZY is non-zero and the length of a string cannot be determined,
 the function instead considers as the maximum possible length the
-size of a character array it may refer to.
+size of a character array it may refer to.  If FUZZY is 2, it will handle
+PHIs and COND_EXPRs optimistically, if we can determine string length
+minimum and maximum, it will use the minimum from the ones where it
+can be determined.
 Set *FLEXP to true if the range of the string lengths has been
 obtained from the upper bound of an array at the end of a struct.
 Such an array may hold a string that's longer than its upper bound
-due to it being used as a poor-man's flexible array member.  */
+due to it being used as a poor-man's flexible array member.
+Pass NONSTR through to children.
+ELTSIZE is 1 for normal single byte character strings, and 2 or
+4 for wide characer strings.  ELTSIZE is by default 1.  */
 static bool
 get_range_strlen (tree arg, tree length[2], bitmap *visited, int type,
-		  bool fuzzy, bool *flexp)
+		  int fuzzy, bool *flexp, unsigned eltsize, tree *nonstr)
 {
-tree var, val;
+tree var, val = NULL_TREE;
 gimple *def_stmt;
-/* The minimum and maximum length.  The MAXLEN pointer stays unchanged
+/* The minimum and maximum length.  */
-but MINLEN may be cleared during the execution of the function.  */
+tree *const minlen = length;
-tree *minlen = length;
 tree *const maxlen = length + 1;
 if (TREE_CODE (arg) != SSA_NAME)
 {
 /* We can end up with &(*iftmp_1)[0] here as well, so handle it.  */
 if (TREE_CODE (arg) == ADDR_EXPR
-	  && TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF
+	  && TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF)
-	  && integer_zerop (TREE_OPERAND (TREE_OPERAND (arg, 0), 1)))
+	{
-	{
+	  tree op = TREE_OPERAND (arg, 0);
-	  tree aop0 = TREE_OPERAND (TREE_OPERAND (arg, 0), 0);
+	  if (integer_zerop (TREE_OPERAND (op, 1)))
-	  if (TREE_CODE (aop0) == INDIRECT_REF
+	    {
-	      && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME)
+	      tree aop0 = TREE_OPERAND (op, 0);
-	    return get_range_strlen (TREE_OPERAND (aop0, 0),
+	      if (TREE_CODE (aop0) == INDIRECT_REF
-				     length, visited, type, fuzzy, flexp);
+		  && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME)
+		return get_range_strlen (TREE_OPERAND (aop0, 0), length,
+					 visited, type, fuzzy, flexp,
+					 eltsize, nonstr);
+	    }
+	  else if (TREE_CODE (TREE_OPERAND (op, 0)) == COMPONENT_REF && fuzzy)
+	    {
+	      /* Fail if an array is the last member of a struct object
+		 since it could be treated as a (fake) flexible array
+		 member.  */
+	      tree idx = TREE_OPERAND (op, 1);
+	      arg = TREE_OPERAND (op, 0);
+	      tree optype = TREE_TYPE (arg);
+	      if (tree dom = TYPE_DOMAIN (optype))
+		if (tree bound = TYPE_MAX_VALUE (dom))
+		  if (TREE_CODE (bound) == INTEGER_CST
+		      && TREE_CODE (idx) == INTEGER_CST
+		      && tree_int_cst_lt (bound, idx))
+		    return false;
+	    }
 	}
 if (type == 2)
 	{
 	  val = arg;
 	  if (TREE_CODE (val) != INTEGER_CST
 	      || tree_int_cst_sgn (val) < 0)
 	    return false;
 	}
 else
-	val = c_strlen (arg, 1);
+	{
+	  c_strlen_data data;
+	  memset (&data, 0, sizeof (c_strlen_data));
+	  val = c_strlen (arg, 1, &data, eltsize);
+	  /* If we potentially had a non-terminated string, then
+	     bubble that information up to the caller.  */
+	  if (!val && data.decl)
+	    {
+	      *nonstr = data.decl;
+	      *minlen = data.len;
+	      *maxlen = data.len;
+	      return type == 0 ? false : true;
+	    }
+	}
 if (!val && fuzzy)
 	{
 	  if (TREE_CODE (arg) == ADDR_EXPR)
 	    return get_range_strlen (TREE_OPERAND (arg, 0), length,
-				     visited, type, fuzzy, flexp);
+				     visited, type, fuzzy, flexp,
+				     eltsize, nonstr);
-	  if (TREE_CODE (arg) == COMPONENT_REF
-	      && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 1))) == ARRAY_TYPE)
+	  if (TREE_CODE (arg) == ARRAY_REF)
+	    {
+	      tree type = TREE_TYPE (TREE_OPERAND (arg, 0));
+	      /* Determine the "innermost" array type.  */
+	      while (TREE_CODE (type) == ARRAY_TYPE
+		     && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
+		type = TREE_TYPE (type);
+	      /* Avoid arrays of pointers.  */
+	      tree eltype = TREE_TYPE (type);
+	      if (TREE_CODE (type) != ARRAY_TYPE
+		  || !INTEGRAL_TYPE_P (eltype))
+		return false;
+	      val = TYPE_SIZE_UNIT (type);
+	      if (!val || integer_zerop (val))
+		return false;
+	      val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
+				 integer_one_node);
+	      /* Set the minimum size to zero since the string in
+		 the array could have zero length.  */
+	      *minlen = ssize_int (0);
+	      if (TREE_CODE (TREE_OPERAND (arg, 0)) == COMPONENT_REF
+		  && type == TREE_TYPE (TREE_OPERAND (arg, 0))
+		  && array_at_struct_end_p (TREE_OPERAND (arg, 0)))
+		*flexp = true;
+	    }
+	  else if (TREE_CODE (arg) == COMPONENT_REF
+		   && (TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 1)))
+		       == ARRAY_TYPE))
 	    {
 	      /* Use the type of the member array to determine the upper
 		 bound on the length of the array.  This may be overly
 		 optimistic if the array itself isn't NUL-terminated and
 		 the caller relies on the subsequent member to contain
-		 the NUL.
+		 the NUL but that would only be considered valid if
+		 the array were the last member of a struct.
 		 Set *FLEXP to true if the array whose bound is being
 		 used is at the end of a struct.  */
 	      if (array_at_struct_end_p (arg))
 		*flexp = true;
 	      arg = TREE_OPERAND (arg, 1);
-	      val = TYPE_SIZE_UNIT (TREE_TYPE (arg));
+	      tree type = TREE_TYPE (arg);
+	      while (TREE_CODE (type) == ARRAY_TYPE
+		     && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
+		type = TREE_TYPE (type);
+	      /* Fail when the array bound is unknown or zero.  */
+	      val = TYPE_SIZE_UNIT (type);
 	      if (!val || integer_zerop (val))
 		return false;
 	      val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
 				 integer_one_node);
 	      /* Set the minimum size to zero since the string in
 		 the array could have zero length.  */
 	      *minlen = ssize_int (0);
 	    }
+	  if (VAR_P (arg))
+	    {
+	      tree type = TREE_TYPE (arg);
+	      if (POINTER_TYPE_P (type))
+		type = TREE_TYPE (type);
+	      if (TREE_CODE (type) == ARRAY_TYPE)
+		{
+		  val = TYPE_SIZE_UNIT (type);
+		  if (!val
+		      || TREE_CODE (val) != INTEGER_CST
+		      || integer_zerop (val))
+		    return false;
+		  val = wide_int_to_tree (TREE_TYPE (val),
+					  wi::sub (wi::to_wide (val), 1));
+		  /* Set the minimum size to zero since the string in
+		     the array could have zero length.  */
+		  *minlen = ssize_int (0);
+		}
+	    }
 	}
 if (!val)
 	return false;
-if (minlen
+if (!*minlen
-	  && (!*minlen
+	  || (type > 0
-	      || (type > 0
+	      && TREE_CODE (*minlen) == INTEGER_CST
-		  && TREE_CODE (*minlen) == INTEGER_CST
+	      && TREE_CODE (val) == INTEGER_CST
-		  && TREE_CODE (val) == INTEGER_CST
+	      && tree_int_cst_lt (val, *minlen)))
-		  && tree_int_cst_lt (val, *minlen))))
 	*minlen = val;
 if (*maxlen)
 	{
 	  if (type > 0)
 length.  */
 if (gimple_assign_single_p (def_stmt)
 || gimple_assign_unary_nop_p (def_stmt))
 {
 tree rhs = gimple_assign_rhs1 (def_stmt);
-	    return get_range_strlen (rhs, length, visited, type, fuzzy, flexp);
+	    return get_range_strlen (rhs, length, visited, type, fuzzy, flexp,
+				     eltsize, nonstr);
 }
 	else if (gimple_assign_rhs_code (def_stmt) == COND_EXPR)
 	  {
-	    tree op2 = gimple_assign_rhs2 (def_stmt);
+	    tree ops[2] = { gimple_assign_rhs2 (def_stmt),
-	    tree op3 = gimple_assign_rhs3 (def_stmt);
+			    gimple_assign_rhs3 (def_stmt) };
-	    return get_range_strlen (op2, length, visited, type, fuzzy, flexp)
-	      && get_range_strlen (op3, length, visited, type, fuzzy, flexp);
+	    for (unsigned int i = 0; i < 2; i++)
-}
+	      if (!get_range_strlen (ops[i], length, visited, type, fuzzy,
+				     flexp, eltsize, nonstr))
+		{
+		  if (fuzzy == 2)
+		    *maxlen = build_all_ones_cst (size_type_node);
+		  else
+		    return false;
+		}
+	    return true;
+	  }
 return false;
 case GIMPLE_PHI:
-	{
+	/* All the arguments of the PHI node must have the same constant
-	  /* All the arguments of the PHI node must have the same constant
+	   length.  */
-	     length.  */
+	for (unsigned i = 0; i < gimple_phi_num_args (def_stmt); i++)
-	  unsigned i;
-	  for (i = 0; i < gimple_phi_num_args (def_stmt); i++)
 {
 tree arg = gimple_phi_arg (def_stmt, i)->def;
 /* If this PHI has itself as an argument, we cannot
 determine the string length of this argument.  However,
 constant string length.  So be optimistic and just
 continue with the next argument.  */
 if (arg == gimple_phi_result (def_stmt))
 continue;
-	    if (!get_range_strlen (arg, length, visited, type, fuzzy, flexp))
+	    if (!get_range_strlen (arg, length, visited, type, fuzzy, flexp,
+				   eltsize, nonstr))
 	      {
-		if (fuzzy)
+		if (fuzzy == 2)
 		  *maxlen = build_all_ones_cst (size_type_node);
 		else
 		  return false;
 	      }
 }
-}
 return true;
 default:
 return false;
 }
 refers to and store each in the first two elements of MINMAXLEN.
 For expressions that point to strings of unknown lengths that are
 character arrays, use the upper bound of the array as the maximum
 length.  For example, given an expression like 'x ? array : "xyz"'
 and array declared as 'char array[8]', MINMAXLEN[0] will be set
-to 3 and MINMAXLEN[1] to 7, the longest string that could be
+to 0 and MINMAXLEN[1] to 7, the longest string that could be
 stored in array.
 Return true if the range of the string lengths has been obtained
 from the upper bound of an array at the end of a struct.  Such
 an array may hold a string that's longer than its upper bound
-due to it being used as a poor-man's flexible array member.  */
+due to it being used as a poor-man's flexible array member.
+STRICT is true if it will handle PHIs and COND_EXPRs conservatively
+and false if PHIs and COND_EXPRs are to be handled optimistically,
+if we can determine string length minimum and maximum; it will use
+the minimum from the ones where it can be determined.
+STRICT false should be only used for warning code.
+When non-null, clear *NONSTR if ARG refers to a constant array
+that is known not be nul-terminated.  Otherwise set it to
+the declaration of the constant non-terminated array.
+ELTSIZE is 1 for normal single byte character strings, and 2 or
+4 for wide characer strings.  ELTSIZE is by default 1.  */
 bool
-get_range_strlen (tree arg, tree minmaxlen[2])
+get_range_strlen (tree arg, tree minmaxlen[2], unsigned eltsize,
+		  bool strict, tree *nonstr /* = NULL */)
 {
 bitmap visited = NULL;
 minmaxlen[0] = NULL_TREE;
 minmaxlen[1] = NULL_TREE;
+tree nonstrbuf;
+if (!nonstr)
+nonstr = &nonstrbuf;
+*nonstr = NULL_TREE;
 bool flexarray = false;
-get_range_strlen (arg, minmaxlen, &visited, 1, true, &flexarray);
+if (!get_range_strlen (arg, minmaxlen, &visited, 1, strict ? 1 : 2,
+			 &flexarray, eltsize, nonstr))
+{
+minmaxlen[0] = NULL_TREE;
+minmaxlen[1] = NULL_TREE;
+}
 if (visited)
 BITMAP_FREE (visited);
 return flexarray;
 }
+/* Return the maximum string length for ARG, counting by TYPE
+(1, 2 or 4 for normal or wide chars).  NONSTR indicates
+if the caller is prepared to handle unterminated strings.
+If an unterminated string is discovered and our caller handles
+unterminated strings, then bubble up the offending DECL and
+return the maximum size.  Otherwise return NULL.  */
 tree
-get_maxval_strlen (tree arg, int type)
+get_maxval_strlen (tree arg, int type, tree *nonstr /* = NULL */)
 {
 bitmap visited = NULL;
 tree len[2] = { NULL_TREE, NULL_TREE };
 bool dummy;
-if (!get_range_strlen (arg, len, &visited, type, false, &dummy))
+/* Set to non-null if ARG refers to an untermianted array.  */
+tree mynonstr = NULL_TREE;
+if (!get_range_strlen (arg, len, &visited, type, 0, &dummy, 1, &mynonstr))
 len[1] = NULL_TREE;
 if (visited)
 BITMAP_FREE (visited);
-return len[1];
+if (nonstr)
+{
+/* For callers prepared to handle unterminated arrays set
+	 *NONSTR to point to the declaration of the array and return
+	 the maximum length/size. */
+*nonstr = mynonstr;
+return len[1];
+}
+/* Fail if the constant array isn't nul-terminated.  */
+return mynonstr ? NULL_TREE : len[1];
 }
 /* Fold function call to builtin strcpy with arguments DEST and SRC.
 If LEN is not NULL, it represents the length of the string to be
 static bool
 gimple_fold_builtin_strcpy (gimple_stmt_iterator *gsi,
 			    tree dest, tree src)
 {
-location_t loc = gimple_location (gsi_stmt (*gsi));
+gimple *stmt = gsi_stmt (*gsi);
+location_t loc = gimple_location (stmt);
 tree fn;
 /* If SRC and DEST are the same (and not volatile), return DEST.  */
 if (operand_equal_p (src, dest, 0))
 {
+/* Issue -Wrestrict unless the pointers are null (those do
+	 not point to objects and so do not indicate an overlap;
+	 such calls could be the result of sanitization and jump
+	 threading).  */
+if (!integer_zerop (dest) && !gimple_no_warning_p (stmt))
+	{
+	  tree func = gimple_call_fndecl (stmt);
+	  warning_at (loc, OPT_Wrestrict,
+		      "%qD source argument is the same as destination",
+		      func);
+	}
 replace_call_with_value (gsi, dest);
 return true;
 }
 if (optimize_function_for_size_p (cfun))
 fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
 if (!fn)
 return false;
-tree len = get_maxval_strlen (src, 0);
+/* Set to non-null if ARG refers to an unterminated array.  */
+tree nonstr = NULL;
+tree len = get_maxval_strlen (src, 0, &nonstr);
+if (nonstr)
+{
+/* Avoid folding calls with unterminated arrays.  */
+if (!gimple_no_warning_p (stmt))
+	warn_string_no_nul (loc, "strcpy", src, nonstr);
+gimple_set_no_warning (stmt, true);
+return false;
+}
 if (!len)
 return false;
 len = fold_convert_loc (loc, size_type_node, len);
 len = size_binop_loc (loc, PLUS_EXPR, len, build_int_cst (size_type_node, 1));
 static bool
 gimple_fold_builtin_strncpy (gimple_stmt_iterator *gsi,
 			     tree dest, tree src, tree len)
 {
-location_t loc = gimple_location (gsi_stmt (*gsi));
+gimple *stmt = gsi_stmt (*gsi);
-tree fn;
+location_t loc = gimple_location (stmt);
+bool nonstring = get_attr_nonstring_decl (dest) != NULL_TREE;
 /* If the LEN parameter is zero, return DEST.  */
 if (integer_zerop (len))
 {
+/* Avoid warning if the destination refers to a an array/pointer
+	 decorate with attribute nonstring.  */
+if (!nonstring)
+	{
+	  tree fndecl = gimple_call_fndecl (stmt);
+	  /* Warn about the lack of nul termination: the result is not
+	     a (nul-terminated) string.  */
+	  tree slen = get_maxval_strlen (src, 0);
+	  if (slen && !integer_zerop (slen))
+	    warning_at (loc, OPT_Wstringop_truncation,
+			"%G%qD destination unchanged after copying no bytes "
+			"from a string of length %E",
+			stmt, fndecl, slen);
+	  else
+	    warning_at (loc, OPT_Wstringop_truncation,
+			"%G%qD destination unchanged after copying no bytes",
+			stmt, fndecl);
+	}
 replace_call_with_value (gsi, dest);
 return true;
 }
 /* We can't compare slen with len as constants below if len is not a
 /* Now, we must be passed a constant src ptr parameter.  */
 tree slen = get_maxval_strlen (src, 0);
 if (!slen || TREE_CODE (slen) != INTEGER_CST)
 return false;
-slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
+/* The size of the source string including the terminating nul.  */
+tree ssize = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
 /* We do not support simplification of this case, though we do
 support it when expanding trees into RTL.  */
 /* FIXME: generate a call to __builtin_memset.  */
-if (tree_int_cst_lt (slen, len))
+if (tree_int_cst_lt (ssize, len))
 return false;
+/* Diagnose truncation that leaves the copy unterminated.  */
+maybe_diag_stxncpy_trunc (*gsi, src, len);
 /* OK transform into builtin memcpy.  */
-fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
+tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
 if (!fn)
 return false;
 len = fold_convert_loc (loc, size_type_node, len);
 len = force_gimple_operand_gsi (gsi, len, true,
 				  NULL_TREE, true, GSI_SAME_STMT);
 gimple *repl = gimple_build_call (fn, 3, dest, src, len);
 replace_call_with_call_and_fold (gsi, repl);
 return true;
 }
 /* Fold function call to builtin strchr or strrchr.
 If both arguments are constant, evaluate and fold the result,
 /* Simplify a call to the strncat builtin.  */
 static bool
 gimple_fold_builtin_strncat (gimple_stmt_iterator *gsi)
 {
-gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
+gimple *stmt = gsi_stmt (*gsi);
 tree dst = gimple_call_arg (stmt, 0);
 tree src = gimple_call_arg (stmt, 1);
 tree len = gimple_call_arg (stmt, 2);
 const char *p = c_getstr (src);
 {
 replace_call_with_value (gsi, dst);
 return true;
 }
-/* If the requested len is greater than or equal to the string
+if (TREE_CODE (len) != INTEGER_CST || !p)
-length, call strcat.  */
+return false;
-if (TREE_CODE (len) == INTEGER_CST && p
-&& compare_tree_int (len, strlen (p)) >= 0)
+unsigned srclen = strlen (p);
-{
-tree fn = builtin_decl_implicit (BUILT_IN_STRCAT);
+int cmpsrc = compare_tree_int (len, srclen);
-/* If the replacement _DECL isn't initialized, don't do the
+/* Return early if the requested len is less than the string length.
-	 transformation.  */
+Warnings will be issued elsewhere later.  */
-if (!fn)
+if (cmpsrc < 0)
-	return false;
+return false;
-gcall *repl = gimple_build_call (fn, 2, dst, src);
+unsigned HOST_WIDE_INT dstsize;
-replace_call_with_call_and_fold (gsi, repl);
-return true;
+bool nowarn = gimple_no_warning_p (stmt);
-}
+if (!nowarn && compute_builtin_object_size (dst, 1, &dstsize))
-return false;
+{
+int cmpdst = compare_tree_int (len, dstsize);
+if (cmpdst >= 0)
+	{
+	  tree fndecl = gimple_call_fndecl (stmt);
+	  /* Strncat copies (at most) LEN bytes and always appends
+	     the terminating NUL so the specified bound should never
+	     be equal to (or greater than) the size of the destination.
+	     If it is, the copy could overflow.  */
+	  location_t loc = gimple_location (stmt);
+	  nowarn = warning_at (loc, OPT_Wstringop_overflow_,
+			       cmpdst == 0
+			       ? G_("%G%qD specified bound %E equals "
+				    "destination size")
+			       : G_("%G%qD specified bound %E exceeds "
+				    "destination size %wu"),
+			       stmt, fndecl, len, dstsize);
+	  if (nowarn)
+	    gimple_set_no_warning (stmt, true);
+	}
+}
+if (!nowarn && cmpsrc == 0)
+{
+tree fndecl = gimple_call_fndecl (stmt);
+location_t loc = gimple_location (stmt);
+/* To avoid possible overflow the specified bound should also
+	 not be equal to the length of the source, even when the size
+	 of the destination is unknown (it's not an uncommon mistake
+	 to specify as the bound to strncpy the length of the source).  */
+if (warning_at (loc, OPT_Wstringop_overflow_,
+		      "%G%qD specified bound %E equals source length",
+		      stmt, fndecl, len))
+	gimple_set_no_warning (stmt, true);
+}
+tree fn = builtin_decl_implicit (BUILT_IN_STRCAT);
+/* If the replacement _DECL isn't initialized, don't do the
+transformation.  */
+if (!fn)
+return false;
+/* Otherwise, emit a call to strcat.  */
+gcall *repl = gimple_build_call (fn, 2, dst, src);
+replace_call_with_call_and_fold (gsi, repl);
+return true;
 }
 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
 LEN, and SIZE.  */
 bool known_result = false;
 switch (fcode)
 	{
 	case BUILT_IN_STRCMP:
+	case BUILT_IN_STRCMP_EQ:
 	  {
 	    r = strcmp (p1, p2);
 	    known_result = true;
 	    break;
 	  }
 	case BUILT_IN_STRNCMP:
+	case BUILT_IN_STRNCMP_EQ:
 	  {
 	    if (length == -1)
 	      break;
 	    r = strncmp (p1, p2, length);
 	    known_result = true;
 	    if (length == -1)
 	      break;
 	    r = strncmp (p1, p2, length);
 	    if (r == 0)
 	      known_result = true;
-	    break;;
+	    break;
 	  }
 	default:
 	  gcc_unreachable ();
 	}
 	}
 }
 bool nonzero_length = length >= 1
 || fcode == BUILT_IN_STRCMP
+|| fcode == BUILT_IN_STRCMP_EQ
 || fcode == BUILT_IN_STRCASECMP;
 location_t loc = gimple_location (stmt);
 /* If the second arg is "", return *(const unsigned char*)arg1.  */
 	  stmt = gimple_build_assign (lhs, MINUS_EXPR, c1, c2);
 	  gimple_seq_add_stmt_without_update (&stmts, stmt);
 	}
 gsi_replace_with_seq_vops (gsi, stmts);
+return true;
+}
+/* If length is larger than the length of one constant string,
+replace strncmp with corresponding strcmp */
+if (fcode == BUILT_IN_STRNCMP
+&& length > 0
+&& ((p2 && (size_t) length > strlen (p2))
+|| (p1 && (size_t) length > strlen (p1))))
+{
+tree fn = builtin_decl_implicit (BUILT_IN_STRCMP);
+if (!fn)
+return false;
+gimple *repl = gimple_build_call (fn, 2, str1, str2);
+replace_call_with_call_and_fold (gsi, repl);
 return true;
 }
 return false;
 }
 tree len, fn;
 /* If SRC and DEST are the same (and not volatile), return DEST.  */
 if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
 {
+/* Issue -Wrestrict unless the pointers are null (those do
+	 not point to objects and so do not indicate an overlap;
+	 such calls could be the result of sanitization and jump
+	 threading).  */
+if (!integer_zerop (dest) && !gimple_no_warning_p (stmt))
+	{
+	  tree func = gimple_call_fndecl (stmt);
+	  warning_at (loc, OPT_Wrestrict,
+		      "%qD source argument is the same as destination",
+		      func);
+	}
 replace_call_with_value (gsi, dest);
 return true;
 }
 if (! tree_fits_uhwi_p (size))
 {
 gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi));
 location_t loc = gimple_location (stmt);
 tree dest = gimple_call_arg (stmt, 0);
 tree src = gimple_call_arg (stmt, 1);
-tree fn, len, lenp1;
+tree fn, lenp1;
 /* If the result is unused, replace stpcpy with strcpy.  */
 if (gimple_call_lhs (stmt) == NULL_TREE)
 {
 tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
 gimple_call_set_fndecl (stmt, fn);
 fold_stmt (gsi);
 return true;
 }
-len = c_strlen (src, 1);
+/* Set to non-null if ARG refers to an unterminated array.  */
+c_strlen_data data;
+memset (&data, 0, sizeof (c_strlen_data));
+tree len = c_strlen (src, 1, &data, 1);
 if (!len
 || TREE_CODE (len) != INTEGER_CST)
-return false;
+{
+data.decl = unterminated_array (src);
+if (!data.decl)
+	return false;
+}
+if (data.decl)
+{
+/* Avoid folding calls with unterminated arrays.  */
+if (!gimple_no_warning_p (stmt))
+	warn_string_no_nul (loc, "stpcpy", src, data.decl);
+gimple_set_no_warning (stmt, true);
+return false;
+}
 if (optimize_function_for_size_p (cfun)
 /* If length is zero it's small enough.  */
 && !integer_zerop (len))
 return false;
 /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
 	 'format' is known to contain no % formats.  */
 gimple_seq stmts = NULL;
 gimple *repl = gimple_build_call (fn, 2, dest, fmt);
+/* Propagate the NO_WARNING bit to avoid issuing the same
+	 warning more than once.  */
+if (gimple_no_warning_p (stmt))
+	gimple_set_no_warning (repl, true);
 gimple_seq_add_stmt_without_update (&stmts, repl);
 if (gimple_call_lhs (stmt))
 	{
 	  repl = gimple_build_assign (gimple_call_lhs (stmt),
 				      build_int_cst (integer_type_node,
 	}
 /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
 gimple_seq stmts = NULL;
 gimple *repl = gimple_build_call (fn, 2, dest, orig);
+/* Propagate the NO_WARNING bit to avoid issuing the same
+	 warning more than once.  */
+if (gimple_no_warning_p (stmt))
+	gimple_set_no_warning (repl, true);
 gimple_seq_add_stmt_without_update (&stmts, repl);
 if (gimple_call_lhs (stmt))
 	{
 	  if (!useless_type_conversion_p (integer_type_node,
 					  TREE_TYPE (orig_len)))
 	  if ((unsigned char)str[len - 1] == target_newline
 	      && (size_t) (int) len == len
 	      && (int) len > 0)
 	    {
 	      char *newstr;
-	      tree offset_node, string_cst;
 	      /* Create a NUL-terminated string that's one char shorter
 		 than the original, stripping off the trailing '\n'.  */
-	      newarg = build_string_literal (len, str);
+	      newstr = xstrdup (str);
-	      string_cst = string_constant (newarg, &offset_node);
-	      gcc_checking_assert (string_cst
-				   && (TREE_STRING_LENGTH (string_cst)
-				       == (int) len)
-				   && integer_zerop (offset_node)
-				   && (unsigned char)
-				      TREE_STRING_POINTER (string_cst)[len - 1]
-				      == target_newline);
-	      /* build_string_literal creates a new STRING_CST,
-		 modify it in place to avoid double copying.  */
-	      newstr = CONST_CAST (char *, TREE_STRING_POINTER (string_cst));
 	      newstr[len - 1] = '\0';
+	      newarg = build_string_literal (len, newstr);
+	      free (newstr);
 	      if (fn_puts)
 		{
 		  gcall *repl = gimple_build_call (fn_puts, 1, newarg);
 		  replace_call_with_call_and_fold (gsi, repl);
 		  return true;
 static bool
 gimple_fold_builtin_strlen (gimple_stmt_iterator *gsi)
 {
 gimple *stmt = gsi_stmt (*gsi);
-tree len = get_maxval_strlen (gimple_call_arg (stmt, 0), 0);
+tree arg = gimple_call_arg (stmt, 0);
-if (!len)
-return false;
+wide_int minlen;
-len = force_gimple_operand_gsi (gsi, len, true, NULL, true, GSI_SAME_STMT);
+wide_int maxlen;
-replace_call_with_value (gsi, len);
-return true;
+/* Set to non-null if ARG refers to an unterminated array.  */
+tree nonstr;
+tree lenrange[2];
+if (!get_range_strlen (arg, lenrange, 1, true, &nonstr)
+&& !nonstr
+&& lenrange[0] && TREE_CODE (lenrange[0]) == INTEGER_CST
+&& lenrange[1] && TREE_CODE (lenrange[1]) == INTEGER_CST)
+{
+/* The range of lengths refers to either a single constant
+	 string or to the longest and shortest constant string
+	 referenced by the argument of the strlen() call, or to
+	 the strings that can possibly be stored in the arrays
+	 the argument refers to.  */
+minlen = wi::to_wide (lenrange[0]);
+maxlen = wi::to_wide (lenrange[1]);
+}
+else
+{
+unsigned prec = TYPE_PRECISION (sizetype);
+minlen = wi::shwi (0, prec);
+maxlen = wi::to_wide (max_object_size (), prec) - 2;
+}
+if (minlen == maxlen)
+{
+lenrange[0] = force_gimple_operand_gsi (gsi, lenrange[0], true, NULL,
+					      true, GSI_SAME_STMT);
+replace_call_with_value (gsi, lenrange[0]);
+return true;
+}
+if (tree lhs = gimple_call_lhs (stmt))
+if (TREE_CODE (lhs) == SSA_NAME
+	&& INTEGRAL_TYPE_P (TREE_TYPE (lhs)))
+set_range_info (lhs, VR_RANGE, minlen, maxlen);
+return false;
 }
 /* Fold a call to __builtin_acc_on_device.  */
 static bool
 case BUILT_IN_STRRCHR:
 return gimple_fold_builtin_strchr (gsi, true);
 case BUILT_IN_STRSTR:
 return gimple_fold_builtin_strstr (gsi);
 case BUILT_IN_STRCMP:
+case BUILT_IN_STRCMP_EQ:
 case BUILT_IN_STRCASECMP:
 case BUILT_IN_STRNCMP:
+case BUILT_IN_STRNCMP_EQ:
 case BUILT_IN_STRNCASECMP:
 return gimple_fold_builtin_string_compare (gsi);
 case BUILT_IN_MEMCHR:
 return gimple_fold_builtin_memchr (gsi);
 case BUILT_IN_FPUTS:
 static tree
 fold_internal_goacc_dim (const gimple *call)
 {
 int axis = oacc_get_ifn_dim_arg (call);
 int size = oacc_get_fn_dim_size (current_function_decl, axis);
-bool is_pos = gimple_call_internal_fn (call) == IFN_GOACC_DIM_POS;
 tree result = NULL_TREE;
+tree type = TREE_TYPE (gimple_call_lhs (call));
-/* If the size is 1, or we only want the size and it is not dynamic,
-we know the answer.  */
+switch (gimple_call_internal_fn (call))
-if (size == 1 || (!is_pos && size))
+{
-{
+case IFN_GOACC_DIM_POS:
-tree type = TREE_TYPE (gimple_call_lhs (call));
+/* If the size is 1, we know the answer.  */
-result = build_int_cst (type, size - is_pos);
+if (size == 1)
+	result = build_int_cst (type, 0);
+break;
+case IFN_GOACC_DIM_SIZE:
+/* If the size is not dynamic, we know the answer.  */
+if (size)
+	result = build_int_cst (type, size);
+break;
+default:
+break;
 }
 return result;
 }
 || VECTOR_TYPE_P (etype)
 || TREE_CODE (etype) == COMPLEX_TYPE
 /* Don't optimize floating point expected vars, VIEW_CONVERT_EXPRs
 	 might not preserve all the bits.  See PR71716.  */
 || SCALAR_FLOAT_TYPE_P (etype)
-|| TYPE_PRECISION (etype) != GET_MODE_BITSIZE (TYPE_MODE (etype)))
+|| maybe_ne (TYPE_PRECISION (etype),
+		   GET_MODE_BITSIZE (TYPE_MODE (etype))))
 return false;
 tree weak = gimple_call_arg (stmt, 3);
 if (!integer_zerop (weak) && !integer_onep (weak))
 return false;
 if (direct_optab_handler (atomic_compare_and_swap_optab, mode)
 == CODE_FOR_nothing
 && optab_handler (sync_compare_and_swap_optab, mode) == CODE_FOR_nothing)
 return false;
-if (int_size_in_bytes (etype) != GET_MODE_SIZE (mode))
+if (maybe_ne (int_size_in_bytes (etype), GET_MODE_SIZE (mode)))
 return false;
 return true;
 }
 gimple_call_set_lhs (g, lhs);
 gimple_set_vdef (g, gimple_vdef (stmt));
 gimple_set_vuse (g, gimple_vuse (stmt));
 SSA_NAME_DEF_STMT (gimple_vdef (g)) = g;
 tree oldlhs = gimple_call_lhs (stmt);
-if (stmt_can_throw_internal (stmt))
+if (stmt_can_throw_internal (cfun, stmt))
 {
 throws = true;
 e = find_fallthru_edge (gsi_bb (*gsi)->succs);
 }
 gimple_call_set_nothrow (as_a <gcall *> (g),
 bool
 arith_overflowed_p (enum tree_code code, const_tree type,
 		    const_tree arg0, const_tree arg1)
 {
-typedef FIXED_WIDE_INT (WIDE_INT_MAX_PRECISION * 2) widest2_int;
-typedef generic_wide_int <wi::extended_tree <WIDE_INT_MAX_PRECISION * 2> >
-widest2_int_cst;
 widest2_int warg0 = widest2_int_cst (arg0);
 widest2_int warg1 = widest2_int_cst (arg1);
 widest2_int wres;
 switch (code)
 {
 	  if (final && targets.length () <= 1 && dbg_cnt (devirt))
 	    {
 	      tree lhs = gimple_call_lhs (stmt);
 	      if (dump_enabled_p ())
 		{
-		  location_t loc = gimple_location_safe (stmt);
+		  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt,
-		  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc,
 				   "folding virtual function call to %s\n",
 		 		   targets.length () == 1
 		  		   ? targets[0]->name ()
 		  		   : "__builtin_unreachable");
 		}
 	{
 	case IFN_BUILTIN_EXPECT:
 	  result = fold_builtin_expect (gimple_location (stmt),
 					gimple_call_arg (stmt, 0),
 					gimple_call_arg (stmt, 1),
-					gimple_call_arg (stmt, 2));
+					gimple_call_arg (stmt, 2),
+					NULL_TREE);
 	  break;
 	case IFN_UBSAN_OBJECT_SIZE:
 	  {
 	    tree offset = gimple_call_arg (stmt, 1);
 	    tree objsize = gimple_call_arg (stmt, 2);
 and the associated statements in *SEQ.  Does the replacement
 according to INPLACE and returns true if the operation succeeded.  */
 static bool
 replace_stmt_with_simplification (gimple_stmt_iterator *gsi,
-				  code_helper rcode, tree *ops,
+				  gimple_match_op *res_op,
 				  gimple_seq *seq, bool inplace)
 {
 gimple *stmt = gsi_stmt (*gsi);
+tree *ops = res_op->ops;
+unsigned int num_ops = res_op->num_ops;
 /* Play safe and do not allow abnormals to be mentioned in
 newly created statements.  See also maybe_push_res_to_seq.
 As an exception allow such uses if there was a use of the
 same SSA name on the old stmt.  */
-if ((TREE_CODE (ops[0]) == SSA_NAME
+for (unsigned int i = 0; i < num_ops; ++i)
-&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[0])
+if (TREE_CODE (ops[i]) == SSA_NAME
-&& !has_use_on_stmt (ops[0], stmt))
+	&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[i])
-|| (ops[1]
+	&& !has_use_on_stmt (ops[i], stmt))
-	  && TREE_CODE (ops[1]) == SSA_NAME
+return false;
-	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[1])
-	  && !has_use_on_stmt (ops[1], stmt))
+if (num_ops > 0 && COMPARISON_CLASS_P (ops[0]))
-|| (ops[2]
+for (unsigned int i = 0; i < 2; ++i)
-	  && TREE_CODE (ops[2]) == SSA_NAME
+if (TREE_CODE (TREE_OPERAND (ops[0], i)) == SSA_NAME
-	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2])
+	  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0], i))
-	  && !has_use_on_stmt (ops[2], stmt))
+	  && !has_use_on_stmt (TREE_OPERAND (ops[0], i), stmt))
-|| (COMPARISON_CLASS_P (ops[0])
+	return false;
-	  && ((TREE_CODE (TREE_OPERAND (ops[0], 0)) == SSA_NAME
-	       && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0], 0))
-	       && !has_use_on_stmt (TREE_OPERAND (ops[0], 0), stmt))
-	      || (TREE_CODE (TREE_OPERAND (ops[0], 1)) == SSA_NAME
-		  && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0], 1))
-		  && !has_use_on_stmt (TREE_OPERAND (ops[0], 1), stmt)))))
-return false;
 /* Don't insert new statements when INPLACE is true, even if we could
 reuse STMT for the final statement.  */
 if (inplace && !gimple_seq_empty_p (*seq))
 return false;
 if (gcond *cond_stmt = dyn_cast <gcond *> (stmt))
 {
-gcc_assert (rcode.is_tree_code ());
+gcc_assert (res_op->code.is_tree_code ());
-if (TREE_CODE_CLASS ((enum tree_code)rcode) == tcc_comparison
+if (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison
 	  /* GIMPLE_CONDs condition may not throw.  */
 	  && (!flag_exceptions
 	      || !cfun->can_throw_non_call_exceptions
-	      || !operation_could_trap_p (rcode,
+	      || !operation_could_trap_p (res_op->code,
 					  FLOAT_TYPE_P (TREE_TYPE (ops[0])),
 					  false, NULL_TREE)))
-	gimple_cond_set_condition (cond_stmt, rcode, ops[0], ops[1]);
+	gimple_cond_set_condition (cond_stmt, res_op->code, ops[0], ops[1]);
-else if (rcode == SSA_NAME)
+else if (res_op->code == SSA_NAME)
 	gimple_cond_set_condition (cond_stmt, NE_EXPR, ops[0],
 				   build_zero_cst (TREE_TYPE (ops[0])));
-else if (rcode == INTEGER_CST)
+else if (res_op->code == INTEGER_CST)
 	{
 	  if (integer_zerop (ops[0]))
 	    gimple_cond_make_false (cond_stmt);
 	  else
 	    gimple_cond_make_true (cond_stmt);
 	}
 else if (!inplace)
 	{
-	  tree res = maybe_push_res_to_seq (rcode, boolean_type_node,
+	  tree res = maybe_push_res_to_seq (res_op, seq);
-					    ops, seq);
 	  if (!res)
 	    return false;
 	  gimple_cond_set_condition (cond_stmt, NE_EXPR, res,
 				     build_zero_cst (TREE_TYPE (res)));
 	}
 	}
 gsi_insert_seq_before (gsi, *seq, GSI_SAME_STMT);
 return true;
 }
 else if (is_gimple_assign (stmt)
-	   && rcode.is_tree_code ())
+	   && res_op->code.is_tree_code ())
 {
 if (!inplace
-	  || gimple_num_ops (stmt) > get_gimple_rhs_num_ops (rcode))
+	  || gimple_num_ops (stmt) > get_gimple_rhs_num_ops (res_op->code))
 	{
-	  maybe_build_generic_op (rcode,
+	  maybe_build_generic_op (res_op);
-				  TREE_TYPE (gimple_assign_lhs (stmt)), ops);
+	  gimple_assign_set_rhs_with_ops (gsi, res_op->code,
-	  gimple_assign_set_rhs_with_ops (gsi, rcode, ops[0], ops[1], ops[2]);
+					  res_op->op_or_null (0),
+					  res_op->op_or_null (1),
+					  res_op->op_or_null (2));
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    {
 	      fprintf (dump_file, "gimple_simplified to ");
 	      if (!gimple_seq_empty_p (*seq))
 		print_gimple_seq (dump_file, *seq, 0, TDF_SLIM);
 	    }
 	  gsi_insert_seq_before (gsi, *seq, GSI_SAME_STMT);
 	  return true;
 	}
 }
-else if (rcode.is_fn_code ()
+else if (res_op->code.is_fn_code ()
-	   && gimple_call_combined_fn (stmt) == rcode)
+	   && gimple_call_combined_fn (stmt) == res_op->code)
 {
-unsigned i;
+gcc_assert (num_ops == gimple_call_num_args (stmt));
-for (i = 0; i < gimple_call_num_args (stmt); ++i)
+for (unsigned int i = 0; i < num_ops; ++i)
-	{
+	gimple_call_set_arg (stmt, i, ops[i]);
-	  gcc_assert (ops[i] != NULL_TREE);
-	  gimple_call_set_arg (stmt, i, ops[i]);
-	}
-if (i < 3)
-	gcc_assert (ops[i] == NULL_TREE);
 if (dump_file && (dump_flags & TDF_DETAILS))
 	{
 	  fprintf (dump_file, "gimple_simplified to ");
 	  if (!gimple_seq_empty_p (*seq))
 	    print_gimple_seq (dump_file, *seq, 0, TDF_SLIM);
 else if (!inplace)
 {
 if (gimple_has_lhs (stmt))
 	{
 	  tree lhs = gimple_get_lhs (stmt);
-	  if (!maybe_push_res_to_seq (rcode, TREE_TYPE (lhs),
+	  if (!maybe_push_res_to_seq (res_op, seq, lhs))
-				      ops, seq, lhs))
 	    return false;
 	  if (dump_file && (dump_flags & TDF_DETAILS))
 	    {
 	      fprintf (dump_file, "gimple_simplified to ");
 	      print_gimple_seq (dump_file, *seq, 0, TDF_SLIM);
 if (TREE_CODE (addr) == ADDR_EXPR
 	  && (TREE_CODE (TREE_OPERAND (addr, 0)) == MEM_REF
 	      || handled_component_p (TREE_OPERAND (addr, 0))))
 	{
 	  tree base;
-	  HOST_WIDE_INT coffset;
+	  poly_int64 coffset;
 	  base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0),
 						&coffset);
 	  if (!base)
 	    gcc_unreachable ();
 if (!inplace
 || is_gimple_assign (stmt)
 || gimple_code (stmt) == GIMPLE_COND)
 {
 gimple_seq seq = NULL;
-code_helper rcode;
+gimple_match_op res_op;
-tree ops[3] = {};
+if (gimple_simplify (stmt, &res_op, inplace ? NULL : &seq,
-if (gimple_simplify (stmt, &rcode, ops, inplace ? NULL : &seq,
 			   valueize, valueize))
 	{
-	  if (replace_stmt_with_simplification (gsi, rcode, ops, &seq, inplace))
+	  if (replace_stmt_with_simplification (gsi, &res_op, &seq, inplace))
 	    changed = true;
 	  else
 	    gimple_seq_discard (seq);
 	}
 }
 follow_single_use_edges (tree val)
 {
 if (TREE_CODE (val) == SSA_NAME
 && !has_single_use (val))
 return NULL_TREE;
+return val;
+}
+/* Valueization callback that follows all SSA edges.  */
+tree
+follow_all_ssa_edges (tree val)
+{
 return val;
 }
 /* Fold the statement pointed to by GSI.  In some cases, this function may
 replace the whole statement with a new one.  Returns true iff folding
 tree
 gimple_fold_stmt_to_constant_1 (gimple *stmt, tree (*valueize) (tree),
 				tree (*gvalueize) (tree))
 {
-code_helper rcode;
+gimple_match_op res_op;
-tree ops[3] = {};
 /* ???  The SSA propagators do not correctly deal with following SSA use-def
 edges if there are intermediate VARYING defs.  For this reason
 do not follow SSA edges here even though SCCVN can technically
 just deal fine with that.  */
-if (gimple_simplify (stmt, &rcode, ops, NULL, gvalueize, valueize))
+if (gimple_simplify (stmt, &res_op, NULL, gvalueize, valueize))
 {
 tree res = NULL_TREE;
-if (gimple_simplified_result_is_gimple_val (rcode, ops))
+if (gimple_simplified_result_is_gimple_val (&res_op))
-	res = ops[0];
+	res = res_op.ops[0];
 else if (mprts_hook)
-	res = mprts_hook (rcode, gimple_expr_type (stmt), ops);
+	res = mprts_hook (&res_op);
 if (res)
 	{
 	  if (dump_file && dump_flags & TDF_DETAILS)
 	    {
 	      fprintf (dump_file, "Match-and-simplified ");
 	      /* Handle propagating invariant addresses into address
 		 operations.  */
 	      else if (TREE_CODE (rhs) == ADDR_EXPR
 		       && !is_gimple_min_invariant (rhs))
 		{
-		  HOST_WIDE_INT offset = 0;
+		  poly_int64 offset = 0;
 		  tree base;
 		  base = get_addr_base_and_unit_offset_1 (TREE_OPERAND (rhs, 0),
 							  &offset,
 							  valueize);
 		  if (base
 		    return build_invariant_address (TREE_TYPE (rhs),
 						    base, offset);
 		}
 	      else if (TREE_CODE (rhs) == CONSTRUCTOR
 		       && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE
-		       && (CONSTRUCTOR_NELTS (rhs)
+		       && known_eq (CONSTRUCTOR_NELTS (rhs),
-			   == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
+				    TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs))))
 		{
 		  unsigned i, nelts;
 		  tree val;
-		  nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs));
+		  nelts = CONSTRUCTOR_NELTS (rhs);
-		  auto_vec<tree, 32> vec (nelts);
+		  tree_vector_builder vec (TREE_TYPE (rhs), nelts, 1);
 		  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val)
 		    {
 		      val = (*valueize) (val);
 		      if (TREE_CODE (val) == INTEGER_CST
 			  || TREE_CODE (val) == REAL_CST
 			vec.quick_push (val);
 		      else
 			return NULL_TREE;
 		    }
-		  return build_vector (TREE_TYPE (rhs), vec);
+		  return vec.build ();
 		}
 	      if (subcode == OBJ_TYPE_REF)
 		{
 		  tree val = (*valueize) (OBJ_TYPE_REF_EXPR (rhs));
 		  /* If callee is constant, we can fold away the wrapper.  */
 	    return NULL_TREE;
 	  }
 	fn = (*valueize) (gimple_call_fn (stmt));
 	if (TREE_CODE (fn) == ADDR_EXPR
-	    && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL
+	    && fndecl_built_in_p (TREE_OPERAND (fn, 0))
-	    && DECL_BUILT_IN (TREE_OPERAND (fn, 0))
 	    && gimple_builtin_call_types_compatible_p (stmt,
 						       TREE_OPERAND (fn, 0)))
 	  {
 	    tree *args = XALLOCAVEC (tree, gimple_call_num_args (stmt));
 	    tree retval;
 As a special case, return error_mark_node when constructor
 is not explicitly available, but it is known to be zero
 such as 'static const int a;'.  */
 static tree
-get_base_constructor (tree base, HOST_WIDE_INT *bit_offset,
+get_base_constructor (tree base, poly_int64_pod *bit_offset,
 		      tree (*valueize)(tree))
 {
-HOST_WIDE_INT bit_offset2, size, max_size;
+poly_int64 bit_offset2, size, max_size;
 bool reverse;
 if (TREE_CODE (base) == MEM_REF)
 {
-if (!integer_zerop (TREE_OPERAND (base, 1)))
+poly_offset_int boff = *bit_offset + mem_ref_offset (base) * BITS_PER_UNIT;
-	{
+if (!boff.to_shwi (bit_offset))
-	  if (!tree_fits_shwi_p (TREE_OPERAND (base, 1)))
+	return NULL_TREE;
-	    return NULL_TREE;
-	  *bit_offset += (mem_ref_offset (base).to_short_addr ()
-			  * BITS_PER_UNIT);
-	}
 if (valueize
 	  && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME)
 	base = valueize (TREE_OPERAND (base, 0));
 if (!base || TREE_CODE (base) != ADDR_EXPR)
 case ARRAY_REF:
 case COMPONENT_REF:
 base = get_ref_base_and_extent (base, &bit_offset2, &size, &max_size,
 				      &reverse);
-if (max_size == -1 || size != max_size)
+if (!known_size_p (max_size) || maybe_ne (size, max_size))
 	return NULL_TREE;
 *bit_offset +=  bit_offset2;
 return get_base_constructor (base, bit_offset, valueize);
 case CONSTRUCTOR:
 return NULL_TREE;
 }
 }
-/* CTOR is CONSTRUCTOR of an array type.  Fold reference of type TYPE and size
+/* CTOR is CONSTRUCTOR of an array type.  Fold a reference of SIZE bits
-SIZE to the memory at bit OFFSET.  */
+to the memory at bit OFFSET.     When non-null, TYPE is the expected
+type of the reference; otherwise the type of the referenced element
+is used instead. When SIZE is zero, attempt to fold a reference to
+the entire element which OFFSET refers to.  Increment *SUBOFF by
+the bit offset of the accessed element.  */
 static tree
 fold_array_ctor_reference (tree type, tree ctor,
 			   unsigned HOST_WIDE_INT offset,
 			   unsigned HOST_WIDE_INT size,
-			   tree from_decl)
+			   tree from_decl,
+			   unsigned HOST_WIDE_INT *suboff)
 {
 offset_int low_bound;
 offset_int elt_size;
 offset_int access_index;
 tree domain_type = NULL_TREE;
 /* Static constructors for variably sized objects makes no sense.  */
 if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))) != INTEGER_CST)
 return NULL_TREE;
 elt_size = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))));
-/* We can handle only constantly sized accesses that are known to not
+/* When TYPE is non-null, verify that it specifies a constant-sized
-be larger than size of array element.  */
+accessed not larger than size of array element.  */
-if (!TYPE_SIZE_UNIT (type)
+if (type
-|| TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
+&& (!TYPE_SIZE_UNIT (type)
-|| elt_size < wi::to_offset (TYPE_SIZE_UNIT (type))
+	  || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
-|| elt_size == 0)
+	  || elt_size < wi::to_offset (TYPE_SIZE_UNIT (type))
+	  || elt_size == 0))
 return NULL_TREE;
 /* Compute the array index we look for.  */
 access_index = wi::udiv_trunc (offset_int (offset / BITS_PER_UNIT),
 				 elt_size);
 /* See if the array field is large enough to span whole access.  We do not
 care to fold accesses spanning multiple array indexes.  */
 if (inner_offset + size > elt_size.to_uhwi () * BITS_PER_UNIT)
 return NULL_TREE;
 if (tree val = get_array_ctor_element_at_index (ctor, access_index))
-return fold_ctor_reference (type, val, inner_offset, size, from_decl);
+{
+if (!size && TREE_CODE (val) != CONSTRUCTOR)
-/* When memory is not explicitely mentioned in constructor,
+	{
-it is 0 (or out of range).  */
+	  /* For the final reference to the entire accessed element
-return build_zero_cst (type);
+	     (SIZE is zero), reset INNER_OFFSET, disegard TYPE (which
-}
+	     may be null) in favor of the type of the element, and set
+	     SIZE to the size of the accessed element.  */
-/* CTOR is CONSTRUCTOR of an aggregate or vector.
+	  inner_offset = 0;
-Fold reference of type TYPE and size SIZE to the memory at bit OFFSET.  */
+	  type = TREE_TYPE (val);
+	  size = elt_size.to_uhwi () * BITS_PER_UNIT;
+	}
+*suboff += (access_index * elt_size * BITS_PER_UNIT).to_uhwi ();
+return fold_ctor_reference (type, val, inner_offset, size, from_decl,
+				  suboff);
+}
+/* Memory not explicitly mentioned in constructor is 0 (or
+the reference is out of range).  */
+return type ? build_zero_cst (type) : NULL_TREE;
+}
+/* CTOR is CONSTRUCTOR of an aggregate or vector.  Fold a reference
+of SIZE bits to the memory at bit OFFSET.   When non-null, TYPE
+is the expected type of the reference; otherwise the type of
+the referenced member is used instead.  When SIZE is zero,
+attempt to fold a reference to the entire member which OFFSET
+refers to; in this case.  Increment *SUBOFF by the bit offset
+of the accessed member.  */
 static tree
 fold_nonarray_ctor_reference (tree type, tree ctor,
 			      unsigned HOST_WIDE_INT offset,
 			      unsigned HOST_WIDE_INT size,
-			      tree from_decl)
+			      tree from_decl,
+			      unsigned HOST_WIDE_INT *suboff)
 {
 unsigned HOST_WIDE_INT cnt;
 tree cfield, cval;
 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), cnt, cfield,
 			    cval)
 {
 tree byte_offset = DECL_FIELD_OFFSET (cfield);
 tree field_offset = DECL_FIELD_BIT_OFFSET (cfield);
 tree field_size = DECL_SIZE (cfield);
-offset_int bitoffset;
-offset_int bitoffset_end, access_end;
+if (!field_size)
+	{
+	  /* Determine the size of the flexible array member from
+	     the size of the initializer provided for it.  */
+	  field_size = TYPE_SIZE (TREE_TYPE (cval));
+	}
 /* Variable sized objects in static constructors makes no sense,
 	 but field_size can be NULL for flexible array members.  */
 gcc_assert (TREE_CODE (field_offset) == INTEGER_CST
 		  && TREE_CODE (byte_offset) == INTEGER_CST
 		  && (field_size != NULL_TREE
 		      ? TREE_CODE (field_size) == INTEGER_CST
 		      : TREE_CODE (TREE_TYPE (cfield)) == ARRAY_TYPE));
 /* Compute bit offset of the field.  */
-bitoffset = (wi::to_offset (field_offset)
+offset_int bitoffset
-		   + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT));
+	= (wi::to_offset (field_offset)
+	   + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT));
 /* Compute bit offset where the field ends.  */
+offset_int bitoffset_end;
 if (field_size != NULL_TREE)
 	bitoffset_end = bitoffset + wi::to_offset (field_size);
 else
 	bitoffset_end = 0;
-access_end = offset_int (offset) + size;
+/* Compute the bit offset of the end of the desired access.
+	 As a special case, if the size of the desired access is
-/* Is there any overlap between [OFFSET, OFFSET+SIZE) and
+	 zero, assume the access is to the entire field (and let
-	 [BITOFFSET, BITOFFSET_END)?  */
+	 the caller make any necessary adjustments by storing
+	 the actual bounds of the field in FIELDBOUNDS).  */
+offset_int access_end = offset_int (offset);
+if (size)
+	access_end += size;
+else
+	access_end = bitoffset_end;
+/* Is there any overlap between the desired access at
+	 [OFFSET, OFFSET+SIZE) and the offset of the field within
+	 the object at [BITOFFSET, BITOFFSET_END)?  */
 if (wi::cmps (access_end, bitoffset) > 0
 	  && (field_size == NULL_TREE
 	      || wi::lts_p (offset, bitoffset_end)))
 	{
-	  offset_int inner_offset = offset_int (offset) - bitoffset;
+	  *suboff += bitoffset.to_uhwi ();
-	  /* We do have overlap.  Now see if field is large enough to
-	     cover the access.  Give up for accesses spanning multiple
+	  if (!size && TREE_CODE (cval) != CONSTRUCTOR)
-	     fields.  */
+	    {
+	      /* For the final reference to the entire accessed member
+		 (SIZE is zero), reset OFFSET, disegard TYPE (which may
+		 be null) in favor of the type of the member, and set
+		 SIZE to the size of the accessed member.  */
+	      offset = bitoffset.to_uhwi ();
+	      type = TREE_TYPE (cval);
+	      size = (bitoffset_end - bitoffset).to_uhwi ();
+	    }
+	  /* We do have overlap.  Now see if the field is large enough
+	     to cover the access.  Give up for accesses that extend
+	     beyond the end of the object or that span multiple fields.  */
 	  if (wi::cmps (access_end, bitoffset_end) > 0)
 	    return NULL_TREE;
 	  if (offset < bitoffset)
 	    return NULL_TREE;
+	  offset_int inner_offset = offset_int (offset) - bitoffset;
 	  return fold_ctor_reference (type, cval,
 				      inner_offset.to_uhwi (), size,
-				      from_decl);
+				      from_decl, suboff);
 	}
 }
-/* When memory is not explicitely mentioned in constructor, it is 0.  */
+/* Memory not explicitly mentioned in constructor is 0.  */
-return build_zero_cst (type);
+return type ? build_zero_cst (type) : NULL_TREE;
 }
-/* CTOR is value initializing memory, fold reference of type TYPE and size SIZE
+/* CTOR is value initializing memory.  Fold a reference of TYPE and
-to the memory at bit OFFSET.  */
+bit size POLY_SIZE to the memory at bit POLY_OFFSET.  When SIZE
+is zero, attempt to fold a reference to the entire subobject
+which OFFSET refers to.  This is used when folding accesses to
+string members of aggregates.  When non-null, set *SUBOFF to
+the bit offset of the accessed subobject.  */
 tree
-fold_ctor_reference (tree type, tree ctor, unsigned HOST_WIDE_INT offset,
+fold_ctor_reference (tree type, tree ctor, const poly_uint64 &poly_offset,
-		     unsigned HOST_WIDE_INT size, tree from_decl)
+		     const poly_uint64 &poly_size, tree from_decl,
+		     unsigned HOST_WIDE_INT *suboff /* = NULL */)
 {
 tree ret;
 /* We found the field with exact match.  */
-if (useless_type_conversion_p (type, TREE_TYPE (ctor))
+if (type
-&& !offset)
+&& useless_type_conversion_p (type, TREE_TYPE (ctor))
+&& known_eq (poly_offset, 0U))
 return canonicalize_constructor_val (unshare_expr (ctor), from_decl);
+/* The remaining optimizations need a constant size and offset.  */
+unsigned HOST_WIDE_INT size, offset;
+if (!poly_size.is_constant (&size) || !poly_offset.is_constant (&offset))
+return NULL_TREE;
 /* We are at the end of walk, see if we can view convert the
 result.  */
 if (!AGGREGATE_TYPE_P (TREE_TYPE (ctor)) && !offset
 /* VIEW_CONVERT_EXPR is defined only for matching sizes.  */
 if (len > 0)
 	return native_interpret_expr (type, buf, len);
 }
 if (TREE_CODE (ctor) == CONSTRUCTOR)
 {
+unsigned HOST_WIDE_INT dummy = 0;
+if (!suboff)
+	suboff = &dummy;
 if (TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE
 	  || TREE_CODE (TREE_TYPE (ctor)) == VECTOR_TYPE)
 	return fold_array_ctor_reference (type, ctor, offset, size,
-					  from_decl);
+					  from_decl, suboff);
-else
-	return fold_nonarray_ctor_reference (type, ctor, offset, size,
+return fold_nonarray_ctor_reference (type, ctor, offset, size,
-					     from_decl);
+					   from_decl, suboff);
 }
 return NULL_TREE;
 }
 tree
 fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree))
 {
 tree ctor, idx, base;
-HOST_WIDE_INT offset, size, max_size;
+poly_int64 offset, size, max_size;
 tree tem;
 bool reverse;
 if (TREE_THIS_VOLATILE (t))
 return NULL_TREE;
 	 (they will be handled only by iteration of ccp).  Perhaps we can bring
 	 get_ref_base_and_extent here and make it use a valueize callback.  */
 if (TREE_CODE (TREE_OPERAND (t, 1)) == SSA_NAME
 	  && valueize
 	  && (idx = (*valueize) (TREE_OPERAND (t, 1)))
-	  && TREE_CODE (idx) == INTEGER_CST)
+	  && poly_int_tree_p (idx))
 	{
 	  tree low_bound, unit_size;
 	  /* If the resulting bit-offset is constant, track it.  */
 	  if ((low_bound = array_ref_low_bound (t),
-	       TREE_CODE (low_bound) == INTEGER_CST)
+	       poly_int_tree_p (low_bound))
 	      && (unit_size = array_ref_element_size (t),
 		  tree_fits_uhwi_p (unit_size)))
 	    {
-	      offset_int woffset
+	      poly_offset_int woffset
-		= wi::sext (wi::to_offset (idx) - wi::to_offset (low_bound),
+		= wi::sext (wi::to_poly_offset (idx)
+			    - wi::to_poly_offset (low_bound),
 			    TYPE_PRECISION (TREE_TYPE (idx)));
-	      if (wi::fits_shwi_p (woffset))
+	      if (woffset.to_shwi (&offset))
 		{
-		  offset = woffset.to_shwi ();
 		  /* TODO: This code seems wrong, multiply then check
 		     to see if it fits.  */
 		  offset *= tree_to_uhwi (unit_size);
 		  offset *= BITS_PER_UNIT;
 		  /* Empty constructor.  Always fold to 0.  */
 		  if (ctor == error_mark_node)
 		    return build_zero_cst (TREE_TYPE (t));
 		  /* Out of bound array access.  Value is undefined,
 		     but don't fold.  */
-		  if (offset < 0)
+		  if (maybe_lt (offset, 0))
 		    return NULL_TREE;
 		  /* We can not determine ctor.  */
 		  if (!ctor)
 		    return NULL_TREE;
 		  return fold_ctor_reference (TREE_TYPE (t), ctor, offset,
 /* Empty constructor.  Always fold to 0.  */
 if (ctor == error_mark_node)
 	return build_zero_cst (TREE_TYPE (t));
 /* We do not know precise address.  */
-if (max_size == -1 || max_size != size)
+if (!known_size_p (max_size) || maybe_ne (max_size, size))
 	return NULL_TREE;
 /* We can not determine ctor.  */
 if (!ctor)
 	return NULL_TREE;
 /* Out of bound array access.  Value is undefined, but don't fold.  */
-if (offset < 0)
+if (maybe_lt (offset, 0))
 	return NULL_TREE;
 return fold_ctor_reference (TREE_TYPE (t), ctor, offset, size,
 				  base);
 folding.  At the moment we do not stream them in all cases,
 but it should never happen that ctor seem unreachable.  */
 gcc_assert (init);
 if (init == error_mark_node)
 {
-gcc_assert (in_lto_p);
 /* Pass down that we lost track of the target.  */
 if (can_refer)
 	*can_refer = false;
 return NULL_TREE;
 }
 elt_size = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (init))));
 access_index = offset / BITS_PER_UNIT / elt_size;
 gcc_checking_assert (offset % (elt_size * BITS_PER_UNIT) == 0);
-/* This code makes an assumption that there are no
+/* The C++ FE can now produce indexed fields, and we check if the indexes
-indexed fileds produced by C++ FE, so we can directly index the array. */
+match.  */
 if (access_index < CONSTRUCTOR_NELTS (init))
 {
 fn = CONSTRUCTOR_ELT (init, access_index)->value;
-gcc_checking_assert (!CONSTRUCTOR_ELT (init, access_index)->index);
+tree idx = CONSTRUCTOR_ELT (init, access_index)->index;
+gcc_checking_assert (!idx || tree_to_uhwi (idx) == access_index);
 STRIP_NOPS (fn);
 }
 else
 fn = NULL;
 tree part_width = TYPE_SIZE (type);
 unsigned HOST_WIDE_INT part_widthi
 = tree_to_shwi (part_width) / BITS_PER_UNIT;
 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
 tree index = bitsize_int (indexi);
-if (offset / part_widthi
+	  if (known_lt (offset / part_widthi,
-	      < TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype)))
+			TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype))))
 return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (addr, 0),
 part_width, index);
 	}
 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
 simplifying it first if possible.  Returns the built
 expression value (or NULL_TREE if TYPE is void) and appends
 statements possibly defining it to SEQ.  */
 tree
-gimple_build (gimple_seq *seq, location_t loc,
+gimple_build (gimple_seq *seq, location_t loc, combined_fn fn,
-	      enum built_in_function fn, tree type, tree arg0)
+	      tree type, tree arg0)
 {
 tree res = gimple_simplify (fn, type, arg0, seq, gimple_build_valueize);
 if (!res)
 {
-tree decl = builtin_decl_implicit (fn);
+gcall *stmt;
-gimple *stmt = gimple_build_call (decl, 1, arg0);
+if (internal_fn_p (fn))
+	stmt = gimple_build_call_internal (as_internal_fn (fn), 1, arg0);
+else
+	{
+	  tree decl = builtin_decl_implicit (as_builtin_fn (fn));
+	  stmt = gimple_build_call (decl, 1, arg0);
+	}
 if (!VOID_TYPE_P (type))
 	{
 	  res = create_tmp_reg_or_ssa_name (type);
 	  gimple_call_set_lhs (stmt, res);
 	}
 simplifying it first if possible.  Returns the built
 expression value (or NULL_TREE if TYPE is void) and appends
 statements possibly defining it to SEQ.  */
 tree
-gimple_build (gimple_seq *seq, location_t loc,
+gimple_build (gimple_seq *seq, location_t loc, combined_fn fn,
-	      enum built_in_function fn, tree type, tree arg0, tree arg1)
+	      tree type, tree arg0, tree arg1)
 {
 tree res = gimple_simplify (fn, type, arg0, arg1, seq, gimple_build_valueize);
 if (!res)
 {
-tree decl = builtin_decl_implicit (fn);
+gcall *stmt;
-gimple *stmt = gimple_build_call (decl, 2, arg0, arg1);
+if (internal_fn_p (fn))
+	stmt = gimple_build_call_internal (as_internal_fn (fn), 2, arg0, arg1);
+else
+	{
+	  tree decl = builtin_decl_implicit (as_builtin_fn (fn));
+	  stmt = gimple_build_call (decl, 2, arg0, arg1);
+	}
 if (!VOID_TYPE_P (type))
 	{
 	  res = create_tmp_reg_or_ssa_name (type);
 	  gimple_call_set_lhs (stmt, res);
 	}
 simplifying it first if possible.  Returns the built
 expression value (or NULL_TREE if TYPE is void) and appends
 statements possibly defining it to SEQ.  */
 tree
-gimple_build (gimple_seq *seq, location_t loc,
+gimple_build (gimple_seq *seq, location_t loc, combined_fn fn,
-	      enum built_in_function fn, tree type,
+	      tree type, tree arg0, tree arg1, tree arg2)
-	      tree arg0, tree arg1, tree arg2)
 {
 tree res = gimple_simplify (fn, type, arg0, arg1, arg2,
 			      seq, gimple_build_valueize);
 if (!res)
 {
-tree decl = builtin_decl_implicit (fn);
+gcall *stmt;
-gimple *stmt = gimple_build_call (decl, 3, arg0, arg1, arg2);
+if (internal_fn_p (fn))
+	stmt = gimple_build_call_internal (as_internal_fn (fn),
+					   3, arg0, arg1, arg2);
+else
+	{
+	  tree decl = builtin_decl_implicit (as_builtin_fn (fn));
+	  stmt = gimple_build_call (decl, 3, arg0, arg1, arg2);
+	}
 if (!VOID_TYPE_P (type))
 	{
 	  res = create_tmp_reg_or_ssa_name (type);
 	  gimple_call_set_lhs (stmt, res);
 	}
 tree
 gimple_build_vector_from_val (gimple_seq *seq, location_t loc, tree type,
 			      tree op)
 {
+if (!TYPE_VECTOR_SUBPARTS (type).is_constant ()
+&& !CONSTANT_CLASS_P (op))
+return gimple_build (seq, loc, VEC_DUPLICATE_EXPR, type, op);
 tree res, vec = build_vector_from_val (type, op);
 if (is_gimple_val (vec))
 return vec;
 if (gimple_in_ssa_p (cfun))
 res = make_ssa_name (type);
 gimple_set_location (stmt, loc);
 gimple_seq_add_stmt_without_update (seq, stmt);
 return res;
 }
-/* Build a vector of type TYPE in which the elements have the values
+/* Build a vector from BUILDER, handling the case in which some elements
-given by ELTS.  Return a gimple value for the result, appending any
+are non-constant.  Return a gimple value for the result, appending any
-new instructions to SEQ.  */
+new instructions to SEQ.
+BUILDER must not have a stepped encoding on entry.  This is because
+the function is not geared up to handle the arithmetic that would
+be needed in the variable case, and any code building a vector that
+is known to be constant should use BUILDER->build () directly.  */
 tree
-gimple_build_vector (gimple_seq *seq, location_t loc, tree type,
+gimple_build_vector (gimple_seq *seq, location_t loc,
-		     vec<tree> elts)
+		     tree_vector_builder *builder)
 {
-unsigned int nelts = elts.length ();
+gcc_assert (builder->nelts_per_pattern () <= 2);
-gcc_assert (nelts == TYPE_VECTOR_SUBPARTS (type));
+unsigned int encoded_nelts = builder->encoded_nelts ();
-for (unsigned int i = 0; i < nelts; ++i)
+for (unsigned int i = 0; i < encoded_nelts; ++i)
-if (!TREE_CONSTANT (elts[i]))
+if (!TREE_CONSTANT ((*builder)[i]))
 {
+	tree type = builder->type ();
+	unsigned int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
 	vec<constructor_elt, va_gc> *v;
 	vec_alloc (v, nelts);
 	for (i = 0; i < nelts; ++i)
-	  CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[i]);
+	  CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, builder->elt (i));
 	tree res;
 	if (gimple_in_ssa_p (cfun))
 	  res = make_ssa_name (type);
 	else
 	gimple *stmt = gimple_build_assign (res, build_constructor (type, v));
 	gimple_set_location (stmt, loc);
 	gimple_seq_add_stmt_without_update (seq, stmt);
 	return res;
 }
-return build_vector (type, elts);
+return builder->build ();
 }
 /* Return true if the result of assignment STMT is known to be non-negative.
 If the return value is based on the assumption that signed overflow is
 undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change

Mercurial > hg > CbC > CbC_gcc

comparison gcc/gimple-fold.c @ 131:84e7813d76e9