[2/4] - relax strlen range optimization to avoid making assumptions about types

[2/4] - Relax strlen range optimization to avoid making assumptions
         about types

This main part of this patch is to relax the strlen range
optimization to avoid relying on array types.  Instead, the function
either removes the upper bound of the strlen result altogether, or
constrains it by the size of referenced declaration (without
attempting to deal with common symbols).

A seemingly "big" change here is splitting up the static
get_range_strlen workhorse into two functions to make it easier
to follow.  The attached cc-99999-2-gimple-fold.c.diff-b shows
the diff for the file without considering whitespace changes.

An important change to the get_range_strlen function worth calling
out to is the introduction of the tight_bound local variable.
It controls whether the upper bound computed by the function is
suitable for optimization (the larger value) or warnings
(the smaller value).

Another important change here is replacing the type and fuzzy
arguments to get_range_strlen with a single enum.  The two arguments
were confusing and with all combinations of their possible values
being meaningful.  The original extern get_range_strlen overload
with the type and fuzzy arguments is retained in this patch to
keep the changes contained.  It is removed in [4/4].

Finally, a large number of tests needed adjusting here.  I also
added a few new tests to better exercise the changes.

diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c
index 8f71e9c..eb77065 100644
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -66,6 +66,9 @@ along with GCC; see the file COPYING3.  If not see
 #include "tree-vector-builder.h"
 #include "tree-ssa-strlen.h"
 
+static bool
+get_range_strlen (tree, bitmap *, StrlenType, strlen_data_t *);
+
 /* 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
@@ -1261,40 +1264,23 @@ gimple_fold_builtin_memset (gimple_stmt_iterator *gsi, tree c, tree len)
   return true;
 }
 
-
-/* Try to obtain the range of the lengths of the string(s) referenced
-   by ARG, or the size of the largest array ARG referes to if the range
-   of lengths cannot be determined, and store all in *PDATA.
-   If ARG is an SSA name variable, follow its use-def chains.  When
-   TYPE == 0, then if PDATA->MAXLEN is not equal to the determined
-   length or 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 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.  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 PDATA->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.
-   Set PDATA->NONSTR if ARG refers to an unterminated constant array.
-   On input, set PDATA->ELTSIZE to 1 for normal single byte character
-   strings, and 2 or 4 for wide characer strings.  */
+/* Helper of get_range_strlen for ARG that is not SSA_NAME.  */
 
 static bool
-get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
+get_range_strlen_tree (tree arg, bitmap *visited, StrlenType type,
 		       strlen_data_t *pdata)
 {
-  tree var, val = NULL_TREE;
-  gimple *def_stmt;
+  gcc_assert (TREE_CODE (arg) != SSA_NAME);
+
+  /* The length computed by this invocation of the function.  */
+  tree val = NULL_TREE;
+
+  /* True if VAL is an optimistic (tight) bound determined from
+     the size of the character array in which the string may be
+     stored.  In that case, the computed VAL is used to set
+     PDATA->MAXSIZE.  */
+  bool tight_bound = false;
 
-  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)
@@ -1306,9 +1292,10 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 	  if (TREE_CODE (aop0) == INDIRECT_REF
 	      && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME)
 	    return get_range_strlen (TREE_OPERAND (aop0, 0), visited, type,
-					 fuzzy, pdata);
+				     pdata);
 	}
-	  else if (TREE_CODE (TREE_OPERAND (op, 0)) == COMPONENT_REF && fuzzy)
+      else if (TREE_CODE (TREE_OPERAND (op, 0)) == COMPONENT_REF
+	       && type == StringSizeRange)
 	{
 	  /* Fail if an array is the last member of a struct object
 	     since it could be treated as a (fake) flexible array
@@ -1326,8 +1313,9 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 	}
     }
 
-      if (type == 2)
+  if (type == IntegerValue)
     {
+      /* We are computing the maximum value (not string length).  */
       val = arg;
       if (TREE_CODE (val) != INTEGER_CST
 	  || tree_int_cst_sgn (val) < 0)
@@ -1336,41 +1324,42 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
   else
     val = c_strlen (arg, 1, &pdata->nonstr, pdata->eltsize);
 
-      if (!val && fuzzy)
+  if (!val && type == StringSizeRange)
     {
       if (TREE_CODE (arg) == ADDR_EXPR)
-	    return get_range_strlen (TREE_OPERAND (arg, 0), visited, type,
-				     fuzzy, pdata);
+	return get_range_strlen (TREE_OPERAND (arg, 0), visited, type, pdata);
 
       if (TREE_CODE (arg) == ARRAY_REF)
 	{
-	      tree type = TREE_TYPE (TREE_OPERAND (arg, 0));
+	  tree optype = 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);
+	  while (TREE_CODE (optype) == ARRAY_TYPE
+		 && TREE_CODE (TREE_TYPE (optype)) == ARRAY_TYPE)
+	    optype = TREE_TYPE (optype);
 
 	  /* Avoid arrays of pointers.  */
-	      tree eltype = TREE_TYPE (type);
-	      if (TREE_CODE (type) != ARRAY_TYPE
+	  tree eltype = TREE_TYPE (optype);
+	  if (TREE_CODE (optype) != ARRAY_TYPE
 	      || !INTEGRAL_TYPE_P (eltype))
 	    return false;
 
-	      val = TYPE_SIZE_UNIT (type);
+	  /* Fail when the array bound is unknown or zero.  */
+	  val = TYPE_SIZE_UNIT (optype);
 	  if (!val || integer_zerop (val))
 	    return false;
 
-	      val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
-				 integer_one_node);
+	  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.  */
 	  pdata->minlen = ssize_int (0);
 
 	  if (TREE_CODE (TREE_OPERAND (arg, 0)) == COMPONENT_REF
-		  && type == TREE_TYPE (TREE_OPERAND (arg, 0))
+	      && optype == TREE_TYPE (TREE_OPERAND (arg, 0))
 	      && array_at_struct_end_p (TREE_OPERAND (arg, 0)))
 	    pdata->flexarray = true;
+
+	  tight_bound = true;
 	}
       else if (TREE_CODE (arg) == COMPONENT_REF
 	       && (TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 1)))
@@ -1381,40 +1370,48 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 	     optimistic if the array itself isn't NUL-terminated and
 	     the caller relies on the subsequent member to contain
 	     the NUL but that would only be considered valid if
-		 the array were the last member of a struct.
+	     the array was 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))
 	    pdata->flexarray = true;
 
-	      arg = TREE_OPERAND (arg, 1);
+	  tree fld = TREE_OPERAND (arg, 1);
 
-	      tree type = TREE_TYPE (arg);
+	  tree optype = TREE_TYPE (fld);
 
-	      while (TREE_CODE (type) == ARRAY_TYPE
-		     && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE)
-		type = TREE_TYPE (type);
+	  /* Determine the "innermost" array type.  */
+	  while (TREE_CODE (optype) == ARRAY_TYPE
+		 && TREE_CODE (TREE_TYPE (optype)) == ARRAY_TYPE)
+	    optype = TREE_TYPE (optype);
 
 	  /* Fail when the array bound is unknown or zero.  */
-	      val = TYPE_SIZE_UNIT (type);
+	  val = TYPE_SIZE_UNIT (optype);
 	  if (!val || integer_zerop (val))
 	    return false;
-	      val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
-				 integer_one_node);
+
+	  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.  */
 	  pdata->minlen = ssize_int (0);
-	    }
 
-	  if (VAR_P (arg))
+	  /* The array size determined above is an optimistic bound
+	     on the length.  If the array isn't nul-terminated the
+	     length computed by the library function would be greater.
+	     Even though using strlen to cross the subobject boundary
+	     is undefined, avoid drawing conclusions from the member
+	     type about the length here.  */
+	  tight_bound = true;
+	}
+      else if (VAR_P (arg))
 	{
-	      tree type = TREE_TYPE (arg);
-	      if (POINTER_TYPE_P (type))
-		type = TREE_TYPE (type);
-
-	      if (TREE_CODE (type) == ARRAY_TYPE)
+	  /* Avoid handling pointers to arrays.  GCC might misuse
+	     a pointer to an array of one bound to point to an array
+	     object of a greater bound.  */
+	  tree argtype = TREE_TYPE (arg);
+	  if (TREE_CODE (argtype) == ARRAY_TYPE)
 	    {
-		  val = TYPE_SIZE_UNIT (type);
+	      val = TYPE_SIZE_UNIT (argtype);
 	      if (!val
 		  || TREE_CODE (val) != INTEGER_CST
 		  || integer_zerop (val))
@@ -1433,7 +1430,7 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 
   /* Adjust the lower bound on the string length as necessary.  */
   if (!pdata->minlen
-	  || (type > 0
+      || (type != StringLength
 	  && TREE_CODE (pdata->minlen) == INTEGER_CST
 	  && TREE_CODE (val) == INTEGER_CST
 	  && tree_int_cst_lt (val, pdata->minlen)))
@@ -1441,13 +1438,16 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 
   if (pdata->maxsize)
     {
-	  /* Adjust the tighter (more optimistic) bound if necessary
-	     and proceed to adjust the more conservative bound.  */
+      /* Adjust the tighter (more optimistic) string length bound
+	 if necessary and proceed to adjust the more conservative
+	 bound.  */
       if (TREE_CODE (val) == INTEGER_CST)
 	{
-	      if (TREE_CODE (pdata->maxsize) == INTEGER_CST
-		  && tree_int_cst_lt (pdata->maxsize, val))
+	  if (TREE_CODE (pdata->maxsize) == INTEGER_CST)
+	    {
+	      if (tree_int_cst_lt (pdata->maxsize, val))
 		pdata->maxsize = val;
+	    }
 	  else
 	    pdata->maxsize = build_all_ones_cst (size_type_node);
 	}
@@ -1457,11 +1457,48 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
   else
     pdata->maxsize = val;
 
+  if (tight_bound)
+    {
+      /* VAL computed above represents an otpimistically tight bound
+	 on the length of the string based on the referenced object's
+	 or subobject's type.  Determine the conservative upper bound
+	 based on the enclosing object's size if possible.  */
+      if (type == StringSizeRange)
+	{
+	  poly_int64 offset;
+	  tree base = get_addr_base_and_unit_offset (arg, &offset);
+	  if (!base)
+	    {
+	      /* When the call above fails due to a non-constant offset
+		 assume the offset is zero and use the size of the whole
+		 enclosing object instead.  */
+	      base = get_base_address (arg);
+	      offset = 0;
+	    }
+	  /* If the base object is a pointer no upper bound on the length
+	     can be determined.  Otherwise the maximum length is equal to
+	     the size of the enclosing object minus the offset of
+	     the referenced subobject minus 1 (for the terminating nul).  */
+	  tree type = TREE_TYPE (base);
+	  if (TREE_CODE (type) == POINTER_TYPE
+	      || !VAR_P (base) || !(val = DECL_SIZE_UNIT (base)))
+	    val = build_all_ones_cst (size_type_node);
+	  else
+	    {
+	      val = DECL_SIZE_UNIT (base);
+	      val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val,
+				 size_int (offset + 1));
+	    }
+	}
+      else
+	return false;
+    }
+
   if (pdata->maxlen)
     {
       /* Adjust the more conservative bound if possible/necessary
 	 and fail otherwise.  */
-	  if (type > 0)
+      if (type != StringLength)
 	{
 	  if (TREE_CODE (pdata->maxlen) != INTEGER_CST
 	      || TREE_CODE (val) != INTEGER_CST)
@@ -1472,12 +1509,44 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 	  return true;
 	}
       else if (simple_cst_equal (val, pdata->maxlen) != 1)
+	{
+	  /* Fail if the length of this ARG is different from that
+	     previosuly determined from another ARG.  */
 	  return false;
 	}
+    }
 
   pdata->maxlen = val;
-      return true;
-    }
+
+  /* When not computing a size-based range, fail if the conservative
+     bound could  not be determined.  */
+  return type == StringSizeRange || !integer_all_onesp (val);
+}
+
+/* For an ARG referencing one or more strings, try to obtain the range
+   of their lengths, or the size of the largest array ARG referes to if
+   the range of lengths cannot be determined, and store all in *PDATA.
+   For an integer ARG (when TYPE == IntegerValue), try to determine
+   the maximum constant value.
+   If ARG is an SSA_NAME, follow its use-def chains.  When TYPE ==
+   StringLength, then if PDATA->MAXLEN is not equal to the determined
+   length or if we are unable to determine the length, return false.
+   TYPE determines the kind of value/range to obtain (see StrlenType).
+   VISITED is a bitmap of visited variables.
+   Set PDATA->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.
+   Set PDATA->NONSTR if ARG refers to an unterminated constant array.
+   On input, set PDATA->ELTSIZE to 1 for normal single byte character
+   strings, and 2 or 4 for wide characer strings.  */
+
+static bool
+get_range_strlen (tree arg, bitmap *visited, StrlenType type,
+		  strlen_data_t *pdata)
+{
+  if (TREE_CODE (arg) != SSA_NAME)
+    return get_range_strlen_tree (arg, visited, type, pdata);
 
   /* If ARG is registered for SSA update we cannot look at its defining
      statement.  */
@@ -1490,20 +1559,17 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
   if (!bitmap_set_bit (*visited, SSA_NAME_VERSION (arg)))
     return true;
 
-  var = arg;
-  def_stmt = SSA_NAME_DEF_STMT (var);
+  tree var = arg;
+  gimple *def_stmt = SSA_NAME_DEF_STMT (var);
 
   switch (gimple_code (def_stmt))
     {
       case GIMPLE_ASSIGN:
-        /* The RHS of the statement defining VAR must either have a
-           constant length or come from another SSA_NAME with a constant
-           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, visited, type, fuzzy, pdata);
+	    return get_range_strlen (rhs, visited, type, pdata);
           }
 	else if (gimple_assign_rhs_code (def_stmt) == COND_EXPR)
 	  {
@@ -1511,20 +1577,25 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 			    gimple_assign_rhs3 (def_stmt) };
 
 	    for (unsigned int i = 0; i < 2; i++)
-	      if (!get_range_strlen (ops[i], visited, type, fuzzy, pdata))
+	      if (!get_range_strlen (ops[i], visited, type,  pdata))
 		{
-		  if (fuzzy != 2)
+		  if (type != StringSizeRange)
 		    return false;
-		  pdata->maxsize = build_all_ones_cst (size_type_node);
-		  pdata->maxlen = pdata->maxsize;
+		  /* Set the length range to the maximum to prevent
+		     it from being adjusted in the next iteration but
+		     leave the more conservative MAXSIZE determined
+		     so far alone (or leave it null if it hasn't been
+		     set yet).  */
+		  pdata->minlen = size_zero_node;
+		  pdata->maxlen = build_all_ones_cst (size_type_node);
 		}
 	    return true;
 	  }
         return false;
 
       case GIMPLE_PHI:
-	/* All the arguments of the PHI node must have the same constant
-	   length.  */
+	/* Unless TYPE == StringSizeRange, all arguments of the PHI node
+	   must have a constant length.  */
 	for (unsigned i = 0; i < gimple_phi_num_args (def_stmt); i++)
           {
             tree arg = gimple_phi_arg (def_stmt, i)->def;
@@ -1538,12 +1609,17 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
             if (arg == gimple_phi_result (def_stmt))
               continue;
 
-	    if (!get_range_strlen (arg, visited, type, fuzzy, pdata))
+	    if (!get_range_strlen (arg, visited, type, pdata))
 	      {
-		if (fuzzy != 2)
+		if (type != StringSizeRange)
 		  return false;
-		pdata->maxsize = build_all_ones_cst (size_type_node);
-		pdata->maxlen = pdata->maxsize;
+		  /* Set the length range to the maximum to prevent
+		     it from being adjusted in subsequent iterations
+		     but leave the more conservative MAXSIZE determined
+		     so far alone (or leave it null if it hasn't been
+		     set yet).  */
+		pdata->minlen = size_zero_node;
+		pdata->maxlen = build_all_ones_cst (size_type_node);
 	      }
           }
         return true;
@@ -1555,30 +1631,28 @@ get_range_strlen (tree arg, bitmap *visited, int type, int fuzzy,
 
 /* Try to obtain the range of the lengths of the string(s) referenced
    by ARG, or the size of the largest array ARG refers to if the range
-   of lengths cannot be determined, and store all in *PDATA.
-   If STRICT is true, handle PHIs and COND_EXPRs conservatively; when
-   it's false to handle PHIs and COND_EXPRs optimistically by storing
-   the minimum and maximum of only those strings whose length can be
-   determined, and ignoring others.
-   STRICT of false should be only used for warning code.  */
+   of lengths cannot be determined, and store all in *PDATA.  */
 
-bool
-get_range_strlen (tree arg, bool strict, strlen_data_t *pdata)
+void
+get_range_strlen (tree arg, strlen_data_t *pdata)
 {
   bitmap visited = NULL;
 
-  if (!get_range_strlen (arg, &visited, /* type = */ 1,
-			 /* fuzzy = */ strict ? 1 : 2, pdata))
+  if (!get_range_strlen (arg, &visited, StringSizeRange, pdata))
     {
-      pdata->minlen = NULL_TREE;
-      pdata->maxsize = NULL_TREE;
-      pdata->maxlen = NULL_TREE;
+      /* On failure extend the length range to an impossible maximum
+	 (a valid MAXLEN must be less than PTRDIFF_MAX - 1.  Other
+	 members can stay unchanged regardless.  */
+      pdata->minlen = size_zero_node;
+      pdata->maxlen = build_all_ones_cst (size_type_node);
     }
 
+  /* Unless it's null, leave the more conservative MAXSIZE unchanged.  */
+  if (!pdata->maxsize)
+    pdata->maxsize = pdata->maxlen;
+
   if (visited)
     BITMAP_FREE (visited);
-
-  return pdata->flexarray;
 }
 
 /* Determine the minimum and maximum value or string length that ARG
@@ -1608,37 +1682,56 @@ get_range_strlen (tree arg, bool strict, strlen_data_t *pdata)
 
 bool
 get_range_strlen (tree arg, tree minmaxlen[2], unsigned eltsize,
-		  bool strict, tree *nonstr /* = NULL */)
+		  bool strict /* = true */, tree *nonstr /* = NULL */)
 {
   strlen_data_t data (eltsize);
 
-  bool ret = get_range_strlen (arg, strict, &data);
+  get_range_strlen (arg, &data);
+  if (strict
+      && integer_zerop (data.minlen)
+      && integer_all_onesp (data.maxlen))
+    minmaxlen[0] = minmaxlen[1] = NULL_TREE;
+  else
+    {
       minmaxlen[0] = data.minlen;
       minmaxlen[1] = data.maxlen;
+    }
 
   if (nonstr)
     *nonstr = data.nonstr;
 
-  return ret;
+  return data.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.
+/* Return the maximum value for ARG given TYPE (see StrlenType).
+   For ARG of pointer types, NONSTR indicates if the caller is
+   prepared to handle unterminated strings.   For integer ARG
+   and when TYPE == IntegerValue, NONSTR must be null.
 
    If an unterminated array is discovered and our caller handles
    unterminated arrays, then bubble up the offending DECL and
    return the maximum size.  Otherwise return NULL.  */
 
-tree
-get_maxval_strlen (tree arg, int type, tree *nonstr /* = NULL */)
+static tree
+get_maxval_strlen (tree arg, StrlenType type, tree *nonstr = NULL)
 {
+  /* A non-null NONSTR is meaningless when determining the maximum
+     value of an integer ARG.  */
+  gcc_assert (type != IntegerValue || nonstr == NULL);
+  /* ARG must have an integral type when TYPE says so.  */
+  gcc_assert (type != IntegerValue || INTEGRAL_TYPE_P (TREE_TYPE (arg)));
+
   bitmap visited = NULL;
 
   strlen_data_t data (1);
 
-  if (!get_range_strlen (arg, &visited, type, /* fuzzy = */ 0, &data))
+  /* Redet DATA.MAXLEN if the call fails or when DATA.MAXLEN
+     is unbounded.  */
+  if (!get_range_strlen (arg, &visited, type, &data))
     data.maxlen = NULL_TREE;
+  else if (data.maxlen && integer_all_onesp (data.maxlen))
+    data.maxlen = NULL_TREE;
+
   if (visited)
     BITMAP_FREE (visited);
 
@@ -1697,7 +1790,7 @@ gimple_fold_builtin_strcpy (gimple_stmt_iterator *gsi,
 
   /* Set to non-null if ARG refers to an unterminated array.  */
   tree nonstr = NULL;
-  tree len = get_maxval_strlen (src, 0, &nonstr);
+  tree len = get_maxval_strlen (src, StringLength, &nonstr);
 
   if (nonstr)
     {
@@ -1743,7 +1836,7 @@ gimple_fold_builtin_strncpy (gimple_stmt_iterator *gsi,
 
 	  /* Warn about the lack of nul termination: the result is not
 	     a (nul-terminated) string.  */
-	  tree slen = get_maxval_strlen (src, 0);
+	  tree slen = get_maxval_strlen (src, StringLength);
 	  if (slen && !integer_zerop (slen))
 	    warning_at (loc, OPT_Wstringop_truncation,
 			"%G%qD destination unchanged after copying no bytes "
@@ -1765,7 +1858,7 @@ gimple_fold_builtin_strncpy (gimple_stmt_iterator *gsi,
     return false;
 
   /* Now, we must be passed a constant src ptr parameter.  */
-  tree slen = get_maxval_strlen (src, 0);
+  tree slen = get_maxval_strlen (src, StringLength);
   if (!slen || TREE_CODE (slen) != INTEGER_CST)
     return false;
 
@@ -1987,7 +2080,7 @@ gimple_fold_builtin_strcat (gimple_stmt_iterator *gsi, tree dst, tree src)
 
   /* If the length of the source string isn't computable don't
      split strcat into strlen and memcpy.  */
-  tree len = get_maxval_strlen (src, 0);
+  tree len = get_maxval_strlen (src, StringLength);
   if (! len)
     return false;
 
@@ -2503,7 +2596,7 @@ gimple_fold_builtin_fputs (gimple_stmt_iterator *gsi,
 
   /* Get the length of the string passed to fputs.  If the length
      can't be determined, punt.  */
-  tree len = get_maxval_strlen (arg0, 0);
+  tree len = get_maxval_strlen (arg0, StringLength);
   if (!len
       || TREE_CODE (len) != INTEGER_CST)
     return false;
@@ -2591,7 +2684,7 @@ gimple_fold_builtin_memory_chk (gimple_stmt_iterator *gsi,
   if (! tree_fits_uhwi_p (size))
     return false;
 
-  tree maxlen = get_maxval_strlen (len, 2);
+  tree maxlen = get_maxval_strlen (len, IntegerValue);
   if (! integer_all_onesp (size))
     {
       if (! tree_fits_uhwi_p (len))
@@ -2692,7 +2785,7 @@ gimple_fold_builtin_stxcpy_chk (gimple_stmt_iterator *gsi,
   if (! tree_fits_uhwi_p (size))
     return false;
 
-  tree maxlen = get_maxval_strlen (src, 1);
+  tree maxlen = get_maxval_strlen (src, StringLengthMax);
   if (! integer_all_onesp (size))
     {
       len = c_strlen (src, 1);
@@ -2787,7 +2880,7 @@ gimple_fold_builtin_stxncpy_chk (gimple_stmt_iterator *gsi,
   if (! tree_fits_uhwi_p (size))
     return false;
 
-  tree maxlen = get_maxval_strlen (len, 2);
+  tree maxlen = get_maxval_strlen (len, IntegerValue);
   if (! integer_all_onesp (size))
     {
       if (! tree_fits_uhwi_p (len))
@@ -2924,7 +3017,7 @@ gimple_fold_builtin_snprintf_chk (gimple_stmt_iterator *gsi,
 
   if (! integer_all_onesp (size))
     {
-      tree maxlen = get_maxval_strlen (len, 2);
+      tree maxlen = get_maxval_strlen (len, IntegerValue);
       if (! tree_fits_uhwi_p (len))
 	{
 	  /* If LEN is not constant, try MAXLEN too.
@@ -3166,7 +3259,7 @@ gimple_fold_builtin_sprintf (gimple_stmt_iterator *gsi)
       tree orig_len = NULL_TREE;
       if (gimple_call_lhs (stmt))
 	{
-	  orig_len = get_maxval_strlen (orig, 0);
+	  orig_len = get_maxval_strlen (orig, StringLength);
 	  if (!orig_len)
 	    return false;
 	}
@@ -3299,7 +3392,7 @@ gimple_fold_builtin_snprintf (gimple_stmt_iterator *gsi)
       if (!orig)
 	return false;
 
-      tree orig_len = get_maxval_strlen (orig, 0);
+      tree orig_len = get_maxval_strlen (orig, StringLength);
       if (!orig_len || TREE_CODE (orig_len) != INTEGER_CST)
 	return false;
 
@@ -3607,33 +3700,20 @@ gimple_fold_builtin_strlen (gimple_stmt_iterator *gsi)
   gimple *stmt = gsi_stmt (*gsi);
   tree arg = gimple_call_arg (stmt, 0);
 
-  wide_int minlen;
-  wide_int maxlen;
-
-  /* Set to non-null if ARG refers to an unterminated array.  */
+  /* NONSTR is set to non-null if ARG refers to an unterminated array.
+     Bail if the argument is unterminated, is a flexible array member
+     or if the length or its range cannot be determined.  */
   tree nonstr;
   tree lenrange[2];
-  if (!get_range_strlen (arg, lenrange, 1, true, &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 (get_range_strlen (arg, lenrange, /* eltsize = */ 1,
+			/* strict = */ true, &nonstr)
+      || nonstr
+      || !lenrange[0] || TREE_CODE (lenrange[0]) != INTEGER_CST
+      || !lenrange[1] || TREE_CODE (lenrange[1]) != INTEGER_CST
+      || integer_all_onesp (lenrange[1]))
+    return false;
 
-  if (minlen == maxlen)
+  if (tree_int_cst_equal (lenrange[0], lenrange[1]))
     {
       lenrange[0] = force_gimple_operand_gsi (gsi, lenrange[0], true, NULL,
 					      true, GSI_SAME_STMT);
@@ -3641,10 +3721,9 @@ gimple_fold_builtin_strlen (gimple_stmt_iterator *gsi)
       return true;
     }
 
+  /* Set the strlen() range to [0, LENRANGE[1]]*/
   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);
+    set_strlen_range (lhs, wi::to_wide (lenrange[1]));
 
   return false;
 }


Message ID	161061f0-c481-9213-bc6c-25f2669a8ba4@gmail.com
State	New
Headers	show Return-Path: <gcc-patches-return-486829-incoming=patchwork.ozlabs.org@gcc.gnu.org> DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :subject:to:message-id:date:mime-version:content-type; q=dns; s= default; b=EO8SVtZOKy164yo/Hd1V03USUJKrPAp2LZm9rIdUu+BU4mPEkCUQ3 v6IsLHWmSsGMUDT5NAax6Sa44YKpT5JwKsV+PIFJoueBturQzEDS195IHMlItA2I 4OR9wsnZKkhJolzOhLNv2Krxs2luTB4BrDpjhdD/Zif2V1LTNVTXa8= Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk Sender: gcc-patches-owner@gcc.gnu.org From: Martin Sebor <msebor@gmail.com> Subject: [PATCH 2/4] - relax strlen range optimization to avoid making assumptions about types To: Gcc Patch List <gcc-patches@gcc.gnu.org>, Jeff Law <law@redhat.com> Message-ID: <161061f0-c481-9213-bc6c-25f2669a8ba4@gmail.com> Date: Tue, 2 Oct 2018 10:37:09 -0600 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.8.0 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------E3601B972C65C7592C8FA63B"
Series	avoid relying on type information in get_range_strlen \| expand [0/4] avoid relying on type information in get_range_strlen [1/4] introduce struct strlen_data_t into gimple-fold [2/4] - relax strlen range optimization to avoid making assumptions about types [3/4] - Change sprintf to use new get_range_strlen overload [4/4] - Replace uses of old get_range_strlen with the new one.

[2/4] - relax strlen range optimization to avoid making assumptions about types

Commit Message

Comments

Patch