diff mbox series

[7/8] tree-dynamic-object-size: Get subobject sizes

Message ID 20211007221432.1029249-8-siddhesh@gotplt.org
State Superseded
Headers show
Series __builtin_dynamic_object_size and more | expand

Commit Message

Siddhesh Poyarekar Oct. 7, 2021, 10:14 p.m. UTC
Adapt subobject computation logic from tree-object-size to make it
work with variable sizes.

gcc/ChangeLog:

	* tree-dynamic-object-size.c (build_cond_branch): New function.
	(compute_object_offset): Use it.
	(get_closest_subobject): New function.
	(addr_dyn_object_size): Call it.  Support subobject size
	computation.

gcc/testsuite/ChangeLog:

	* gcc.dg/builtin-dynamic-object-size-0.c
	(test_dynarray_struct_subobj): New test.
	(main): Call it.

Signed-off-by: Siddhesh Poyarekar <siddhesh@gotplt.org>
---
 .../gcc.dg/builtin-dynamic-object-size-0.c    |  34 ++++
 gcc/tree-dynamic-object-size.c                | 172 ++++++++++++++++--
 2 files changed, 194 insertions(+), 12 deletions(-)
diff mbox series

Patch

diff --git a/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c b/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c
index c72fa0508db..94f8e071e2c 100644
--- a/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c
+++ b/gcc/testsuite/gcc.dg/builtin-dynamic-object-size-0.c
@@ -237,6 +237,33 @@  test_dynarray_struct (size_t sz, size_t off)
   return __builtin_dynamic_object_size (&bin[off].c, 0);
 }
 
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_subobj (size_t sz, size_t off)
+{
+  struct dynarray_struct bin[sz];
+
+  return __builtin_dynamic_object_size (&bin[off].c[4], 1);
+}
+
+size_t
+__attribute__ ((noinline))
+test_dynarray_struct_subobj2 (size_t sz, size_t off, size_t *objsz)
+{
+  struct dynarray_struct2
+    {
+      long a;
+      int b;
+      char c[sz];
+    };
+
+  struct dynarray_struct2 bin;
+
+  *objsz = sizeof (bin);
+
+  return __builtin_dynamic_object_size (&bin.c[off], 1);
+}
+
 size_t
 __attribute__ ((noinline))
 test_substring (size_t sz, size_t off)
@@ -334,6 +361,13 @@  main (int argc, char **argv)
     FAIL ();
   if (test_substring (128, 142) != 0)
     FAIL ();
+  if (test_dynarray_struct_subobj (42, 4) != 16 - 4)
+    FAIL ();
+  if (test_dynarray_struct_subobj (42, 48) != 0)
+    FAIL ();
+  size_t objsz = 0;
+  if (test_dynarray_struct_subobj2 (42, 4, &objsz) != objsz - 4 - 12)
+    FAIL ();
   if (test_substring_ptrplus (128, 4) != (128 - 4) * sizeof (int))
     FAIL ();
   if (test_substring_ptrplus (128, 142) != 0)
diff --git a/gcc/tree-dynamic-object-size.c b/gcc/tree-dynamic-object-size.c
index 8d7283623dc..ebc2fad7a87 100644
--- a/gcc/tree-dynamic-object-size.c
+++ b/gcc/tree-dynamic-object-size.c
@@ -102,12 +102,21 @@  static bitmap computed[4];
 bool compute_builtin_dyn_object_size (tree, int, tree *,
 				      struct function *fun = NULL);
 
+static tree
+build_cond_branch (tree t, tree low_bound, tree unit_size)
+{
+  tree br = fold_build2 (MINUS_EXPR, TREE_TYPE (t), t, low_bound);
+  br = fold_convert (sizetype, br);
+  br = fold_build2 (MULT_EXPR, sizetype, unit_size, br);
+
+  return br;
+}
+
 /* Compute offset of EXPR within VAR.  Return error_mark_node if unknown.  */
 
 static tree
 compute_object_offset (const_tree expr, const_tree var)
 {
-  enum tree_code code = PLUS_EXPR;
   tree base, off, t;
 
   if (expr == var)
@@ -150,12 +159,16 @@  compute_object_offset (const_tree expr, const_tree var)
       low_bound = array_ref_low_bound (CONST_CAST_TREE (expr));
       unit_size = array_ref_element_size (CONST_CAST_TREE (expr));
       if (! integer_zerop (low_bound))
-	t = fold_build2 (MINUS_EXPR, TREE_TYPE (t), t, low_bound);
-      if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
 	{
-	  code = MINUS_EXPR;
-	  t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
+	  tree cond = fold_build2 (GE_EXPR, TREE_TYPE (t), t, low_bound);
+	  tree then_br = build_cond_branch (t, low_bound, unit_size);
+	  tree else_br = build_cond_branch (low_bound, t, unit_size);
+
+	  then_br = fold_build2 (PLUS_EXPR, sizetype, base, then_br);
+	  else_br = fold_build2 (MINUS_EXPR, sizetype, base, else_br);
+	  return fold_build3 (COND_EXPR, sizetype, cond, then_br, else_br);
 	}
+
       t = fold_convert (sizetype, t);
       off = fold_build2 (MULT_EXPR, sizetype, unit_size, t);
       break;
@@ -168,7 +181,7 @@  compute_object_offset (const_tree expr, const_tree var)
       return error_mark_node;
     }
 
-  return fold_build2 (code, sizetype, base, off);
+  return fold_build2 (PLUS_EXPR, sizetype, base, off);
 }
 
 /* Given an object size SZ and offset OFF into it, compute the usable object
@@ -328,6 +341,105 @@  whole_var_size (struct object_size_info *osi, tree pt_var,
   return true;
 }
 
+/* Get the most immediate subobject encapsulating the pointer PTR, given the
+   whole_var object WHOLE_VAR.  */
+
+static tree
+get_closest_subobject (const_tree ptr, tree whole_var)
+{
+  tree var = TREE_OPERAND (ptr, 0);
+
+  while (var != whole_var
+	 && TREE_CODE (var) != BIT_FIELD_REF
+	 && TREE_CODE (var) != COMPONENT_REF
+	 && TREE_CODE (var) != ARRAY_REF
+	 && TREE_CODE (var) != ARRAY_RANGE_REF
+	 && TREE_CODE (var) != REALPART_EXPR
+	 && TREE_CODE (var) != IMAGPART_EXPR)
+    var = TREE_OPERAND (var, 0);
+
+  if (var != whole_var && TREE_CODE (var) == ARRAY_REF)
+    var = TREE_OPERAND (var, 0);
+
+  if (! TYPE_SIZE_UNIT (TREE_TYPE (var)))
+    var = whole_var;
+  else if (var != whole_var && TREE_CODE (whole_var) == MEM_REF)
+    {
+      tree v = var;
+      while (v && v != whole_var)
+	switch (TREE_CODE (v))
+	  {
+	  case ARRAY_REF:
+	    if (TYPE_SIZE_UNIT (TREE_TYPE (TREE_OPERAND (v, 0))))
+	      {
+		tree domain
+		  = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (v, 0)));
+		if (domain && TYPE_MAX_VALUE (domain))
+		  {
+		    v = NULL_TREE;
+		    break;
+		  }
+	      }
+	    v = TREE_OPERAND (v, 0);
+	    break;
+	  case REALPART_EXPR:
+	  case IMAGPART_EXPR:
+	    v = NULL_TREE;
+	    break;
+	  case COMPONENT_REF:
+	    if (TREE_CODE (TREE_TYPE (v)) != ARRAY_TYPE)
+	      {
+		v = NULL_TREE;
+		break;
+	      }
+	    while (v != whole_var && TREE_CODE (v) == COMPONENT_REF)
+	      if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
+		  != UNION_TYPE
+		  && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
+		  != QUAL_UNION_TYPE)
+		break;
+	      else
+		v = TREE_OPERAND (v, 0);
+	    if (TREE_CODE (v) == COMPONENT_REF
+		&& TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
+		== RECORD_TYPE)
+	      {
+		tree fld_chain = DECL_CHAIN (TREE_OPERAND (v, 1));
+		for (; fld_chain; fld_chain = DECL_CHAIN (fld_chain))
+		  if (TREE_CODE (fld_chain) == FIELD_DECL)
+		    break;
+
+		if (fld_chain)
+		  {
+		    v = NULL_TREE;
+		    break;
+		  }
+		v = TREE_OPERAND (v, 0);
+	      }
+	    while (v != whole_var && TREE_CODE (v) == COMPONENT_REF)
+	      if (TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
+		  != UNION_TYPE
+		  && TREE_CODE (TREE_TYPE (TREE_OPERAND (v, 0)))
+		  != QUAL_UNION_TYPE)
+		break;
+	      else
+		v = TREE_OPERAND (v, 0);
+	    if (v != whole_var)
+	      v = NULL_TREE;
+	    else
+	      v = whole_var;
+	    break;
+	  default:
+	    v = whole_var;
+	    break;
+	  }
+      if (v == whole_var)
+	var = whole_var;
+    }
+
+  return var;
+}
+
 /* Compute an object size estimate for PTR, which is a ADDR_EXPR.
    OBJECT_SIZE_TYPE is the second argument from __builtin_dynamic_object_size.
    If unknown, return false, setting PSIZE to NULL_TREE.  */
@@ -337,7 +449,8 @@  addr_dyn_object_size (struct object_size_info *osi, const_tree ptr,
 		      int object_size_type, tree *psize,
 		      tree *wholesizep = NULL)
 {
-  tree pt_var, pt_var_size = NULL_TREE, bytes;
+  struct function *fun = osi ? osi->fun : cfun;
+  tree pt_var, pt_var_size = NULL_TREE, var_size, bytes;
 
   gcc_assert (TREE_CODE (ptr) == ADDR_EXPR);
 
@@ -353,22 +466,57 @@  addr_dyn_object_size (struct object_size_info *osi, const_tree ptr,
   if (!whole_var_size (osi, pt_var, object_size_type, &pt_var_size))
     return false;
 
-  if (!pt_var_size)
-    return false;
+  var_size = pt_var_size;
 
   /* PTR points to a subobject of whole variable PT_VAR.  */
   if (pt_var != TREE_OPERAND (ptr, 0))
     {
-      bytes = compute_object_offset (TREE_OPERAND (ptr, 0), pt_var);
+      tree var;
+
+      if (object_size_type & 1)
+	var = get_closest_subobject (ptr, pt_var);
+      else
+	var = pt_var;
+
+      if (var != pt_var)
+	{
+	  var_size = TYPE_SIZE_UNIT (TREE_TYPE (var));
+	  if (!TREE_CONSTANT (var_size))
+	    var_size = get_or_create_ssa_default_def (fun, var_size);
+	  if (!var_size)
+	    return false;
+	}
+      else if (!pt_var_size)
+	return false;
+
+      bytes = compute_object_offset (TREE_OPERAND (ptr, 0), var);
       if (bytes != error_mark_node)
-	bytes = size_for_offset (pt_var_size, bytes, pt_var_size);
+	{
+	  tree cap_size = pt_var_size;
+
+	  /* For subobject sizes where the whole object is a structure,
+	     restrict size to the size of the struct less the offset of the
+	     subobject in the struct.  */
+	  if (var != pt_var && pt_var_size && TREE_CODE (pt_var) == MEM_REF)
+	    {
+	      tree off = compute_object_offset (TREE_OPERAND (ptr, 0), pt_var);
+	      if (off == error_mark_node)
+		off = size_zero_node;
+	      else
+		off = fold_build2 (MIN_EXPR, sizetype, pt_var_size, off);
+	      cap_size = fold_build2 (MINUS_EXPR, sizetype, pt_var_size, off);
+	    }
+	  bytes = size_for_offset (var_size, bytes, cap_size);
+	}
     }
+  else if (!pt_var_size)
+    return false;
   else
     bytes = pt_var_size;
 
   *psize = bytes == error_mark_node ? NULL_TREE : bytes;
   if (wholesizep)
-    *wholesizep = pt_var_size;
+    *wholesizep = var_size;
   return true;
 }