builtins: Fix up two bugs in access_ref::inform_access [PR98721]

The following patch fixes two bugs in the access_ref::inform_access function
(plus some formatting nits).

The first problem is that ref can be various things, e.g. *_DECL, or
SSA_NAME, or IDENTIFIER_NODE.  And allocfn is non-NULL only if ref is
(at least originally) an SSA_NAME initialized to the result of some
allocator function (but not e.g. __builtin_alloca_with_align which is
handled differently).

A few lines above the last hunk of this patch in builtins.c, the code uses
  if (mode == access_read_write || mode == access_write_only)
    {
      if (allocfn == NULL_TREE)
        {
          if (*offstr)
            inform (loc, "at offset %s into destination object %qE of size %s",
                    offstr, ref, sizestr);
          else
            inform (loc, "destination object %qE of size %s", ref, sizestr);
          return;
        }

      if (*offstr)
        inform (loc,
                "at offset %s into destination object of size %s "
                "allocated by %qE", offstr, sizestr, allocfn);
      else
        inform (loc, "destination object of size %s allocated by %qE",
                sizestr, allocfn);
      return;
    }
so if allocfn is NULL, it prints whatever ref is, if it is non-NULL,
it prints instead the allocation function.  But strangely the hunk
a few lines below wasn't consistent with that and instead printed the
first form only if DECL_P (ref) and would ICE if ref wasn't a decl but
still allocfn was NULL.  Fixed by making it consistent what the code does
earlier.

Another bug is that the code earlier contains an ugly hack for VLAs and was
assuming that SSA_NAME_IDENTIFIER must be non-NULL on the lhs of
__builtin_alloca_with_align.  While that is likely true for the cases where
the compiler emits this builtin for VLAs (and it will also be true that
the name of the VLA in that case can be taken from that identifier up to the
first .), the builtin is user accessible as the testcase shows, so one can
have any other SSA_NAME in there.  I think it would be better to add some
more reliable way how to identify VLA names corresponding to
__builtin_alloca_with_align allocations, perhaps internal fn or whatever,
but that is beyond the scope of this patch.

2021-01-20  Jakub Jelinek  <jakub@redhat.com>

	PR tree-optimization/98721
	* builtins.c (access_ref::inform_access): Don't assume
	SSA_NAME_IDENTIFIER must be non-NULL.  Print messages about
	object whenever allocfn is NULL, rather than only when DECL_P
	is true.  Use %qE instead of %qD for that.  Formatting fixes.

	* gcc.dg/pr98721-1.c: New test.
	* gcc.dg/pr98721-2.c: New test.

diff --git a/gcc/builtins.c b/gcc/builtins.c
index c1115a32d91c08dd0e8075af654a51fae7de2f7d..0aed008687ccc9ca81f5f1d340b3d7c4a1fa2990 100644 (file)
--- a/gcc/builtins.c
+++ b/gcc/builtins.c
@@ -4414,8 +4414,8 @@ access_ref::inform_access (access_mode mode) const
         MAXREF on which the result is based.  */
       const offset_int orng[] =
        {
-        offrng[0] - maxref.offrng[0],
-        wi::smax (offrng[1] - maxref.offrng[1], offrng[0]),
+         offrng[0] - maxref.offrng[0],
+         wi::smax (offrng[1] - maxref.offrng[1], offrng[0]),
        };
 
       /* Add the final PHI's offset to that of each of the arguments
@@ -4493,12 +4493,15 @@ access_ref::inform_access (access_mode mode) const
              /* Strip the SSA_NAME suffix from the variable name and
                 recreate an identifier with the VLA's original name.  */
              ref = gimple_call_lhs (stmt);
-             ref = SSA_NAME_IDENTIFIER (ref);
-             const char *id = IDENTIFIER_POINTER (ref);
-             size_t len = strcspn (id, ".$");
-             if (!len)
-               len = strlen (id);
-             ref = get_identifier_with_length (id, len);
+             if (SSA_NAME_IDENTIFIER (ref))
+               {
+                 ref = SSA_NAME_IDENTIFIER (ref);
+                 const char *id = IDENTIFIER_POINTER (ref);
+                 size_t len = strcspn (id, ".$");
+                 if (!len)
+                   len = strlen (id);
+                 ref = get_identifier_with_length (id, len);
+               }
            }
          else
            {
@@ -4557,13 +4560,13 @@ access_ref::inform_access (access_mode mode) const
       return;
     }
 
-  if (DECL_P (ref))
+  if (allocfn == NULL_TREE)
     {
       if (*offstr)
-       inform (loc, "at offset %s into source object %qD of size %s",
+       inform (loc, "at offset %s into source object %qE of size %s",
                offstr, ref, sizestr);
       else
-       inform (loc, "source object %qD of size %s", ref,  sizestr);
+       inform (loc, "source object %qE of size %s", ref, sizestr);
 
       return;
     }

diff --git a/gcc/testsuite/gcc.dg/pr98721-1.c b/gcc/testsuite/gcc.dg/pr98721-1.c
new file mode 100644 (file)
index 0000000..868b071
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr98721-1.c
@@ -0,0 +1,14 @@
+/* PR tree-optimization/98721 */
+/* { dg-do compile } */
+/* { dg-options "-O2" } */
+
+int
+foo (int n)
+{
+  if (n <= 0)
+    {
+      char vla[n];                     /* { dg-message "source object 'vla' of size 0" } */
+      return __builtin_strlen (vla);   /* { dg-warning "'__builtin_strlen' reading 1 or more bytes from a region of size 0" } */
+    }
+  return -1;
+}

diff --git a/gcc/testsuite/gcc.dg/pr98721-2.c b/gcc/testsuite/gcc.dg/pr98721-2.c
new file mode 100644 (file)
index 0000000..c8ca542
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr98721-2.c
@@ -0,0 +1,8 @@
+/* PR tree-optimization/98721 */
+/* { dg-do compile } */
+
+int
+foo (void)
+{
+  return __builtin_strlen (__builtin_alloca_with_align (0, 16));       /* { dg-warning "'__builtin_strlen' reading 1 or more bytes from a region of size 0" } */
+}      /* { dg-message "source object '<unknown>' of size 0" "" { target *-*-* } .-1 } */