tree
unterminated_array (tree exp)
{
- tree nonstr = NULL;
- c_strlen (exp, 1, &nonstr);
- return nonstr;
+ c_strlen_data data;
+ memset (&data, 0, sizeof (c_strlen_data));
+ c_strlen (exp, 1, &data);
+ return data.decl;
}
/* Compute the length of a null-terminated character string or wide
accesses. Note that this implies the result is not going to be emitted
into the instruction stream.
- If a not zero-terminated string value is encountered and NONSTR is
- non-zero, the declaration of the string value is assigned to *NONSTR.
- *NONSTR is accumulating, thus not cleared on success, therefore it has
- to be initialized to NULL_TREE by the caller.
+ Additional information about the string accessed may be recorded
+ in DATA. For example, if SRC references an unterminated string,
+ then the declaration will be stored in the DECL field. If the
+ length of the unterminated string can be determined, it'll be
+ stored in the LEN field. Note this length could well be different
+ than what a C strlen call would return.
ELTSIZE is 1 for normal single byte character strings, and 2 or
4 for wide characer strings. ELTSIZE is by default 1.
The value returned is of type `ssizetype'. */
tree
-c_strlen (tree src, int only_value, tree *nonstr, unsigned eltsize)
+c_strlen (tree src, int only_value, c_strlen_data *data, unsigned eltsize)
{
+ /* If we were not passed a DATA pointer, then get one to a local
+ structure. That avoids having to check DATA for NULL before
+ each time we want to use it. */
+ c_strlen_data local_strlen_data;
+ memset (&local_strlen_data, 0, sizeof (c_strlen_data));
+ if (!data)
+ data = &local_strlen_data;
+
gcc_checking_assert (eltsize == 1 || eltsize == 2 || eltsize == 4);
STRIP_NOPS (src);
if (TREE_CODE (src) == COND_EXPR
{
tree len1, len2;
- len1 = c_strlen (TREE_OPERAND (src, 1), only_value, nonstr, eltsize);
- len2 = c_strlen (TREE_OPERAND (src, 2), only_value, nonstr, eltsize);
+ len1 = c_strlen (TREE_OPERAND (src, 1), only_value, data, eltsize);
+ len2 = c_strlen (TREE_OPERAND (src, 2), only_value, data, eltsize);
if (tree_int_cst_equal (len1, len2))
return len1;
}
if (TREE_CODE (src) == COMPOUND_EXPR
&& (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
- return c_strlen (TREE_OPERAND (src, 1), only_value, nonstr, eltsize);
+ return c_strlen (TREE_OPERAND (src, 1), only_value, data, eltsize);
location_t loc = EXPR_LOC_OR_LOC (src, input_location);
start searching for it. */
unsigned len = string_length (ptr, eltsize, strelts);
- /* Return when an embedded null character is found or none at all. */
+ /* Return when an embedded null character is found or none at all.
+ In the latter case, set the DECL/LEN field in the DATA structure
+ so that callers may examine them. */
if (len + 1 < strelts)
return NULL_TREE;
else if (len >= maxelts)
{
- if (nonstr && decl)
- *nonstr = decl;
+ data->decl = decl;
+ data->len = ssize_int (len);
return NULL_TREE;
}
strelts - eltoff);
/* Don't know what to return if there was no zero termination.
- Ideally this would turn into a gcc_checking_assert over time. */
+ Ideally this would turn into a gcc_checking_assert over time.
+ Set DECL/LEN so callers can examine them. */
if (len >= maxelts - eltoff)
{
- if (nonstr && decl)
- *nonstr = decl;
+ data->decl = decl;
+ data->len = ssize_int (len);
return NULL_TREE;
}
compile-time, not an expression containing a string. This is
because the latter will potentially produce pessimized code
when used to produce the return value. */
- tree nonstr = NULL_TREE;
+ c_strlen_data data;
+ memset (&data, 0, sizeof (c_strlen_data));
if (!c_getstr (src, NULL)
- || !(len = c_strlen (src, 0, &nonstr, 1)))
+ || !(len = c_strlen (src, 0, &data, 1)))
return expand_movstr (dst, src, target, /*endp=*/2);
- if (nonstr && !TREE_NO_WARNING (exp))
- warn_string_no_nul (EXPR_LOCATION (exp), "stpcpy", src, nonstr);
+ if (data.decl && !TREE_NO_WARNING (exp))
+ warn_string_no_nul (EXPR_LOCATION (exp), "stpcpy", src, data.decl);
lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
ret = expand_builtin_mempcpy_args (dst, src, lenp1,
return NULL_TREE;
else
{
- tree nonstr = NULL_TREE;
- tree len = c_strlen (arg, 0, &nonstr);
+ c_strlen_data data;
+ memset (&data, 0, sizeof (c_strlen_data));
+ tree len = c_strlen (arg, 0, &data);
if (len)
return fold_convert_loc (loc, type, len);
- if (!nonstr)
- c_strlen (arg, 1, &nonstr);
+ if (!data.decl)
+ c_strlen (arg, 1, &data);
- if (nonstr)
+ if (data.decl)
{
if (EXPR_HAS_LOCATION (arg))
loc = EXPR_LOCATION (arg);
else if (loc == UNKNOWN_LOCATION)
loc = input_location;
- warn_string_no_nul (loc, "strlen", arg, nonstr);
+ warn_string_no_nul (loc, "strlen", arg, data.decl);
}
return NULL_TREE;
return false;
}
else
- val = c_strlen (arg, 1, nonstr, eltsize);
+ {
+ 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)
+ {
+ *nonstr = data.decl;
+ /* If TYPE is asking for a maximum, then use any
+ length (including the length of an unterminated
+ string) for VAL. */
+ if (type == 2)
+ val = data.len;
+ }
+ }
if (!val && fuzzy)
{
}
/* Set to non-null if ARG refers to an unterminated array. */
- tree nonstr = NULL;
- tree len = c_strlen (src, 1, &nonstr, 1);
+ 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)
{
- nonstr = unterminated_array (src);
- if (!nonstr)
+ data.decl = unterminated_array (src);
+ if (!data.decl)
return false;
}
- if (nonstr)
+ if (data.decl)
{
/* Avoid folding calls with unterminated arrays. */
if (!gimple_no_warning_p (stmt))
- warn_string_no_nul (loc, "stpcpy", src, nonstr);
+ warn_string_no_nul (loc, "stpcpy", src, data.decl);
gimple_set_no_warning (stmt, true);
return false;
}
projects / platform / upstream / gcc.git / commitdiff