From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lf1-x134.google.com (mail-lf1-x134.google.com [IPv6:2a00:1450:4864:20::134]) by sourceware.org (Postfix) with ESMTPS id B93443882110 for ; Tue, 28 May 2024 07:40:10 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org B93443882110 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org B93443882110 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::134 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716882014; cv=none; b=lZjTNa3x2o+nHOxn2QbuGwXC9wB3xYe1lFPXeSrogGDIZ1372SICNdjBUOAcCudtKQ4GbqFLv75ecic8GnQ9Kgvu30oU8jmWvJxrhns2CjQeeHqBrHfrCbCroAwIDLUSXmyqredgxcyG8atDaJ633BQiCq7kLoujYoxnLP/6TH4= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1716882014; c=relaxed/simple; bh=h3MCaj7HjtnzpLxfEHgOvpf0LSQmLAOabedBMV/4iKo=; h=DKIM-Signature:MIME-Version:From:Date:Message-ID:Subject:To; b=GX4yrYVhn7oke/xUSUp/CvnHCD0se8lNXpuXvgHv6Kcjx32haypX0cP/UpSOKz8pqoIqBQ3bH0Gsj7hE17h3s1NeZRoMi1aCSoVGiTwJf6jsMJVh+9fOvfT/Oq/2HzkHobmUK45inaQsLCDcjf8tIkRT3gMDu9yAQVBejLO6Ivw= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-lf1-x134.google.com with SMTP id 2adb3069b0e04-5295bcb9bc1so567089e87.0 for ; Tue, 28 May 2024 00:40:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1716882009; x=1717486809; darn=gcc.gnu.org; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:from:to:cc:subject:date :message-id:reply-to; bh=eI40SF4eYwdhiiNkEjJYWuGx0YJsjcxf8kUfOJwc2xc=; b=ONHiJc+aAYv2lqi8/fL1A/LpTmpqdPyiiI8NwO8TCguam8JRX6QYFSzxQIH5TDN75T bOXSQ40mlk4XPYzYPRn3qgKwiHi9hBOgx3wp1PlU+SlqE7w6PBu5OgZ0Tk1Bd4Be8Nit 50bJsW/QDJXe7TYiRW7ggHMeb5lEuwDgZK3wp1W1Rsn54JS+ppKQM7juMeFDEWcDLb3x IFPeFQYO2Th57zxPNCGUK5+SB3zLinqkFJVgZqQzyqEEd9fZAQ0QsKoXUfwc3AguD+XN +rD2HjtIWnGG5xddCfqZeYzb3cseJEMKINyN/8JPgPMqD+fj9O9seMIlXcY/o7g3pAbO vbNQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1716882009; x=1717486809; h=content-transfer-encoding:cc:to:subject:message-id:date:from :in-reply-to:references:mime-version:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=eI40SF4eYwdhiiNkEjJYWuGx0YJsjcxf8kUfOJwc2xc=; b=HgwOoXe32vhZogJdzNauqeFk7fLSX9kcyp0ze/iZVau9loBbT2Y4oBJXPI1qgSTzYa KeCgaao+JWjxaS1/HvXm1q71h9I2NDmgiHqU7sjMlPI6uqqYvaKJEQFAkx6K2LpsWseI sINAmtqfCSTpcyIwz1W3C+aTdzIc3aCZkVz7LKzd0NR6FK7dGDWAuCpRPKHtKPvD+D19 bRomMRclVJV6ToxIrMVGPEzlG7lauup2YTZx1k9hKmFQzMTh40WdWkRPGdS9hOnX5BLY 9uRmI1MGCbMwQUApcNuY59usHAAK0NoSju8nfzweZs5CeFBNycsNdXWusYuaHQvV1UT/ cm0A== X-Forwarded-Encrypted: i=1; AJvYcCVUENlq3WNQoJO9BW41QhNGhpe54joViZ22Y/cLG5G4NhqanwVz5aGTu2llM5WD8+oFMZknq9zXWfbh7EWAw7yghqMRIDfH6w== X-Gm-Message-State: AOJu0Ywj2bxvLp61x5SOac6l6xqYAW/uRn+U1Pat+Lhy4uziux6lUrYV /RnwXZ3RsitLHrF2C3wpxZnhVJf8ERZokwkoq+zizqP1xzHjKwC3AQym94XOxiBAnDwdtKjjDys bd/zgSgr0EmOpPk2hIWrcdA3Xk7NBuQ== X-Google-Smtp-Source: AGHT+IELgyHPvxjt/Ex7bcc7AKrc8j5XFDHy8FyjE2xRuhp+iZjJHIIOcWjlmluo5FOMDM/+kSlkT2yo55ofwfm/8P8= X-Received: by 2002:a05:6512:20c4:b0:523:8cc2:e01a with SMTP id 2adb3069b0e04-529647d80e5mr6771321e87.2.1716882008806; Tue, 28 May 2024 00:40:08 -0700 (PDT) MIME-Version: 1.0 References: <20240412135430.4122328-1-qing.zhao@oracle.com> <20240412135430.4122328-4-qing.zhao@oracle.com> In-Reply-To: <20240412135430.4122328-4-qing.zhao@oracle.com> From: Richard Biener Date: Tue, 28 May 2024 09:39:57 +0200 Message-ID: Subject: Re: [PATCH v9 3/5] Use the .ACCESS_WITH_SIZE in builtin object size. To: Qing Zhao Cc: josmyers@redhat.com, siddhesh@gotplt.org, uecker@tugraz.at, keescook@chromium.org, isanbard@gmail.com, gcc-patches@gcc.gnu.org Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Spam-Status: No, score=-7.7 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,GIT_PATCH_0,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On Fri, Apr 12, 2024 at 3:54=E2=80=AFPM Qing Zhao wr= ote: > I have no comments here, if Siddesh is OK with this I approve. > gcc/ChangeLog: > > * tree-object-size.cc (access_with_size_object_size): New functio= n. > (call_object_size): Call the new function. > > gcc/testsuite/ChangeLog: > > * gcc.dg/builtin-object-size-common.h: Add a new macro EXPECT. > * gcc.dg/flex-array-counted-by-3.c: New test. > * gcc.dg/flex-array-counted-by-4.c: New test. > * gcc.dg/flex-array-counted-by-5.c: New test. > --- > .../gcc.dg/builtin-object-size-common.h | 11 ++ > .../gcc.dg/flex-array-counted-by-3.c | 63 +++++++ > .../gcc.dg/flex-array-counted-by-4.c | 178 ++++++++++++++++++ > .../gcc.dg/flex-array-counted-by-5.c | 48 +++++ > gcc/tree-object-size.cc | 60 ++++++ > 5 files changed, 360 insertions(+) > create mode 100644 gcc/testsuite/gcc.dg/flex-array-counted-by-3.c > create mode 100644 gcc/testsuite/gcc.dg/flex-array-counted-by-4.c > create mode 100644 gcc/testsuite/gcc.dg/flex-array-counted-by-5.c > > diff --git a/gcc/testsuite/gcc.dg/builtin-object-size-common.h b/gcc/test= suite/gcc.dg/builtin-object-size-common.h > index 66ff7cdd953a..b677067c6e6b 100644 > --- a/gcc/testsuite/gcc.dg/builtin-object-size-common.h > +++ b/gcc/testsuite/gcc.dg/builtin-object-size-common.h > @@ -30,3 +30,14 @@ unsigned nfails =3D 0; > __builtin_abort (); = \ > return 0; = \ > } while (0) > + > +#define EXPECT(p, _v) do { = \ > + size_t v =3D _v; = \ > + if (p =3D=3D v) = \ > + __builtin_printf ("ok: %s =3D=3D %zd\n", #p, p); = \ > + else = \ > + { = \ > + __builtin_printf ("WAT: %s =3D=3D %zd (expected %zd)\n", #p, p, v)= ; \ > + FAIL (); = \ > + } = \ > +} while (0); > diff --git a/gcc/testsuite/gcc.dg/flex-array-counted-by-3.c b/gcc/testsui= te/gcc.dg/flex-array-counted-by-3.c > new file mode 100644 > index 000000000000..78f50230e891 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/flex-array-counted-by-3.c > @@ -0,0 +1,63 @@ > +/* Test the attribute counted_by and its usage in > + * __builtin_dynamic_object_size. */ > +/* { dg-do run } */ > +/* { dg-options "-O2" } */ > + > +#include "builtin-object-size-common.h" > + > +struct flex { > + int b; > + int c[]; > +} *array_flex; > + > +struct annotated { > + int b; > + int c[] __attribute__ ((counted_by (b))); > +} *array_annotated; > + > +struct nested_annotated { > + struct { > + union { > + int b; > + float f; > + }; > + int n; > + }; > + int c[] __attribute__ ((counted_by (b))); > +} *array_nested_annotated; > + > +void __attribute__((__noinline__)) setup (int normal_count, int attr_cou= nt) > +{ > + array_flex > + =3D (struct flex *)malloc (sizeof (struct flex) > + + normal_count * sizeof (int)); > + array_flex->b =3D normal_count; > + > + array_annotated > + =3D (struct annotated *)malloc (sizeof (struct annotated) > + + attr_count * sizeof (int)); > + array_annotated->b =3D attr_count; > + > + array_nested_annotated > + =3D (struct nested_annotated *)malloc (sizeof (struct nested_annotat= ed) > + + attr_count * sizeof (int)); > + array_nested_annotated->b =3D attr_count; > + > + return; > +} > + > +void __attribute__((__noinline__)) test () > +{ > + EXPECT(__builtin_dynamic_object_size(array_flex->c, 1), -1); > + EXPECT(__builtin_dynamic_object_size(array_annotated->c, 1), > + array_annotated->b * sizeof (int)); > + EXPECT(__builtin_dynamic_object_size(array_nested_annotated->c, 1), > + array_nested_annotated->b * sizeof (int)); > +} > + > +int main(int argc, char *argv[]) > +{ > + setup (10,10); > + test (); > + DONE (); > +} > diff --git a/gcc/testsuite/gcc.dg/flex-array-counted-by-4.c b/gcc/testsui= te/gcc.dg/flex-array-counted-by-4.c > new file mode 100644 > index 000000000000..20103d58ef51 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/flex-array-counted-by-4.c > @@ -0,0 +1,178 @@ > +/* Test the attribute counted_by and its usage in > +__builtin_dynamic_object_size: what's the correct behavior when the > +allocation size mismatched with the value of counted_by attribute? > +We should always use the latest value that is hold by the counted_by > +field. */ > +/* { dg-do run } */ > +/* { dg-options "-O -fstrict-flex-arrays=3D3" } */ > + > +#include "builtin-object-size-common.h" > + > +struct annotated { > + size_t foo; > + char others; > + char array[] __attribute__((counted_by (foo))); > +}; > + > +#define noinline __attribute__((__noinline__)) > +#define SIZE_BUMP 10 > +#define MAX(a, b) ((a) > (b) ? (a) : (b)) > + > +/* In general, Due to type casting, the type for the pointee of a pointe= r > + does not say anything about the object it points to, > + So, __builtin_object_size can not directly use the type of the pointe= e > + to decide the size of the object the pointer points to. > + > + There are only two reliable ways: > + A. observed allocations (call to the allocation functions in the rou= tine) > + B. observed accesses (read or write access to the location of the > + pointer points to) > + > + That provide information about the type/existence of an object at > + the corresponding address. > + > + For A, we use the "alloc_size" attribute for the corresponding alloca= tion > + functions to determine the object size; > + (We treat counted_by attribute the same as the "alloc_size" attribute= ) > + > + For B, we use the SIZE info of the TYPE attached to the corresponding= access. > + > + The only other way in C which ensures that a pointer actually points > + to an object of the correct type is 'static': > + > + void foo(struct P *p[static 1]); > + > + See https://gcc.gnu.org/pipermail/gcc-patches/2023-July/624814.html > + for more details. */ > + > +/* In the following function, malloc allocated more space than the value > + of counted_by attribute. Then what's the correct behavior we expect > + the __builtin_dynamic_object_size should have for each of the cases? = */ > + > +static struct annotated * noinline alloc_buf_more (size_t index) > +{ > + struct annotated *p; > + size_t allocated_size > + =3D MAX (sizeof (struct annotated), > + (__builtin_offsetof (struct annotated, array[0]) > + + (index + SIZE_BUMP) * sizeof (char))); > + p =3D (struct annotated *) malloc (allocated_size); > + > + p->foo =3D index; > + > + /* When checking the observed access p->array, we have info on both > + observered allocation and observed access, > + A.1 from observed allocation: > + allocated_size - offsetof (struct annotated, array[0]) > + > + A.2 from the counted-by attribute: > + p->foo * sizeof (char) > + > + We always use the latest value that is hold by the counted-by field. > + */ > + > + EXPECT(__builtin_dynamic_object_size(p->array, 0), > + (p->foo) * sizeof(char)); > + > + EXPECT(__builtin_dynamic_object_size(p->array, 1), > + (p->foo) * sizeof(char)); > + > + EXPECT(__builtin_dynamic_object_size(p->array, 2), > + (p->foo) * sizeof(char)); > + > + EXPECT(__builtin_dynamic_object_size(p->array, 3), > + (p->foo) * sizeof(char)); > + > + /* When checking the pointer p, we only have info on the observed allo= cation. > + So, the object size info can only been obtained from the call to mal= loc. > + For both MAXIMUM and MINIMUM: A =3D (index + SIZE_BUMP) * sizeof (ch= ar) */ > + EXPECT(__builtin_dynamic_object_size(p, 0), allocated_size); > + EXPECT(__builtin_dynamic_object_size(p, 1), allocated_size); > + EXPECT(__builtin_dynamic_object_size(p, 2), allocated_size); > + EXPECT(__builtin_dynamic_object_size(p, 3), allocated_size); > + return p; > +} > + > +/* In the following function, malloc allocated less space than the value > + of counted_by attribute. Then what's the correct behavior we expect > + the __builtin_dynamic_object_size should have for each of the cases? > + NOTE: this is an user error, GCC should issue warnings for such case. > + This is a seperate issue we should address later. */ > + > +static struct annotated * noinline alloc_buf_less (size_t index) > +{ > + struct annotated *p; > + size_t allocated_size > + =3D MAX (sizeof (struct annotated), > + (__builtin_offsetof (struct annotated, array[0]) > + + (index) * sizeof (char))); > + p =3D (struct annotated *) malloc (allocated_size); > + > + p->foo =3D index + SIZE_BUMP; > + > + /* When checking the observed access p->array, we have info on both > + observered allocation and observed access, > + A.1 from observed allocation: > + allocated_size - offsetof (struct annotated, array[0]) > + A.2 from the counted-by attribute: > + p->foo * sizeof (char) > + > + We always use the latest value that is hold by the counted-by field. > + */ > + > + EXPECT(__builtin_dynamic_object_size(p->array, 0), > + (p->foo) * sizeof(char)); > + > + EXPECT(__builtin_dynamic_object_size(p->array, 1), > + (p->foo) * sizeof(char)); > + > + EXPECT(__builtin_dynamic_object_size(p->array, 2), > + (p->foo) * sizeof(char)); > + > + EXPECT(__builtin_dynamic_object_size(p->array, 3), > + (p->foo) * sizeof(char)); > + > + /* When checking the pointer p, we only have info on the observed > + allocation. So, the object size info can only been obtained from > + the call to malloc. */ > + EXPECT(__builtin_dynamic_object_size(p, 0), allocated_size); > + EXPECT(__builtin_dynamic_object_size(p, 1), allocated_size); > + EXPECT(__builtin_dynamic_object_size(p, 2), allocated_size); > + EXPECT(__builtin_dynamic_object_size(p, 3), allocated_size); > + return p; > +} > + > +int main () > +{ > + struct annotated *p, *q; > + p =3D alloc_buf_more (10); > + q =3D alloc_buf_less (10); > + > + /* When checking the access p->array, we only have info on the counted= -by > + value. */ > + EXPECT(__builtin_dynamic_object_size(p->array, 0), p->foo * sizeof(cha= r)); > + EXPECT(__builtin_dynamic_object_size(p->array, 1), p->foo * sizeof(cha= r)); > + EXPECT(__builtin_dynamic_object_size(p->array, 2), p->foo * sizeof(cha= r)); > + EXPECT(__builtin_dynamic_object_size(p->array, 3), p->foo * sizeof(cha= r)); > + /* When checking the pointer p, we have no observed allocation nor obs= erved > + access, therefore, we cannot determine the size info here. */ > + EXPECT(__builtin_dynamic_object_size(p, 0), -1); > + EXPECT(__builtin_dynamic_object_size(p, 1), -1); > + EXPECT(__builtin_dynamic_object_size(p, 2), 0); > + EXPECT(__builtin_dynamic_object_size(p, 3), 0); > + > + /* When checking the access p->array, we only have info on the counted= -by > + value. */ > + EXPECT(__builtin_dynamic_object_size(q->array, 0), q->foo * sizeof(cha= r)); > + EXPECT(__builtin_dynamic_object_size(q->array, 1), q->foo * sizeof(cha= r)); > + EXPECT(__builtin_dynamic_object_size(q->array, 2), q->foo * sizeof(cha= r)); > + EXPECT(__builtin_dynamic_object_size(q->array, 3), q->foo * sizeof(cha= r)); > + /* When checking the pointer p, we have no observed allocation nor obs= erved > + access, therefore, we cannot determine the size info here. */ > + EXPECT(__builtin_dynamic_object_size(q, 0), -1); > + EXPECT(__builtin_dynamic_object_size(q, 1), -1); > + EXPECT(__builtin_dynamic_object_size(q, 2), 0); > + EXPECT(__builtin_dynamic_object_size(q, 3), 0); > + > + DONE (); > +} > diff --git a/gcc/testsuite/gcc.dg/flex-array-counted-by-5.c b/gcc/testsui= te/gcc.dg/flex-array-counted-by-5.c > new file mode 100644 > index 000000000000..68f9b0f7c8d2 > --- /dev/null > +++ b/gcc/testsuite/gcc.dg/flex-array-counted-by-5.c > @@ -0,0 +1,48 @@ > +/* Test the attribute counted_by and its usage in > + * __builtin_dynamic_object_size: when the counted_by field is negative.= */ > +/* { dg-do run } */ > +/* { dg-options "-O2" } */ > + > +#include "builtin-object-size-common.h" > + > +struct annotated { > + int b; > + int c[] __attribute__ ((counted_by (b))); > +} *array_annotated; > + > +struct nested_annotated { > + struct { > + union { > + int b; > + float f; > + }; > + int n; > + }; > + int c[] __attribute__ ((counted_by (b))); > +} *array_nested_annotated; > + > +void __attribute__((__noinline__)) setup (int attr_count) > +{ > + array_annotated > + =3D (struct annotated *)malloc (sizeof (struct annotated)); > + array_annotated->b =3D attr_count; > + > + array_nested_annotated > + =3D (struct nested_annotated *)malloc (sizeof (struct nested_annotat= ed)); > + array_nested_annotated->b =3D attr_count -1; > + > + return; > +} > + > +void __attribute__((__noinline__)) test () > +{ > + EXPECT(__builtin_dynamic_object_size(array_annotated->c, 1), 0); > + EXPECT(__builtin_dynamic_object_size(array_nested_annotated->c, 1), = 0); > +} > + > +int main(int argc, char *argv[]) > +{ > + setup (-10); > + test (); > + DONE (); > +} > diff --git a/gcc/tree-object-size.cc b/gcc/tree-object-size.cc > index 018fbc30cbb6..8de264d1dee2 100644 > --- a/gcc/tree-object-size.cc > +++ b/gcc/tree-object-size.cc > @@ -37,6 +37,7 @@ along with GCC; see the file COPYING3. If not see > #include "attribs.h" > #include "builtins.h" > #include "gimplify-me.h" > +#include "gimplify.h" > > struct object_size_info > { > @@ -60,6 +61,7 @@ static tree compute_object_offset (tree, const_tree); > static bool addr_object_size (struct object_size_info *, > const_tree, int, tree *, tree *t =3D NULL); > static tree alloc_object_size (const gcall *, int); > +static tree access_with_size_object_size (const gcall *, int); > static tree pass_through_call (const gcall *); > static void collect_object_sizes_for (struct object_size_info *, tree); > static void expr_object_size (struct object_size_info *, tree, tree); > @@ -749,6 +751,60 @@ addr_object_size (struct object_size_info *osi, cons= t_tree ptr, > return false; > } > > +/* Compute __builtin_object_size for a CALL to .ACCESS_WITH_SIZE, > + OBJECT_SIZE_TYPE is the second argument from __builtin_object_size. > + The 2nd, 3rd, and the 4th parameters of the call determine the size o= f > + the CALL: > + > + 2nd argument REF_TO_SIZE: The reference to the size of the object, > + 3rd argument CLASS_OF_SIZE: The size referenced by the REF_TO_SIZE re= presents > + 0: the number of bytes; > + 1: the number of the elements of the object type; > + 4th argument TYPE_OF_SIZE: A constant 0 with its TYPE being the same = as the TYPE > + of the object referenced by REF_TO_SIZE > + > + The size of the element can be retrived from the result type of the c= all, > + which is the pointer to the array type. */ > +static tree > +access_with_size_object_size (const gcall *call, int object_size_type) > +{ > + /* If not for dynamic object size, return. */ > + if ((object_size_type & OST_DYNAMIC) =3D=3D 0) > + return size_unknown (object_size_type); > + > + gcc_assert (gimple_call_internal_p (call, IFN_ACCESS_WITH_SIZE)); > + /* Result type is a pointer type to the original flexible array type. = */ > + tree result_type =3D gimple_call_return_type (call); > + gcc_assert (POINTER_TYPE_P (result_type)); > + tree element_size =3D TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (result_typ= e))); > + tree ref_to_size =3D gimple_call_arg (call, 1); > + unsigned int class_of_size =3D TREE_INT_CST_LOW (gimple_call_arg (call= , 2)); > + tree type =3D TREE_TYPE (gimple_call_arg (call, 3)); > + > + tree size =3D fold_build2 (MEM_REF, type, ref_to_size, > + build_int_cst (ptr_type_node, 0)); > + > + /* If size is negative value, treat it as zero. */ > + if (!TYPE_UNSIGNED (type)) > + { > + tree cond_expr =3D fold_build2 (LT_EXPR, boolean_type_node, > + unshare_expr (size), build_zero_cst (ty= pe)); > + size =3D fold_build3 (COND_EXPR, integer_type_node, cond_expr, > + build_zero_cst (type), size); > + } > + > + if (class_of_size =3D=3D 1) > + size =3D size_binop (MULT_EXPR, > + fold_convert (sizetype, size), > + fold_convert (sizetype, element_size)); > + else > + size =3D fold_convert (sizetype, size); > + > + if (!todo) > + todo =3D TODO_update_ssa_only_virtuals; > + > + return size; > +} > > /* Compute __builtin_object_size for CALL, which is a GIMPLE_CALL. > Handles calls to functions declared with attribute alloc_size. > @@ -1350,8 +1406,12 @@ call_object_size (struct object_size_info *osi, tr= ee ptr, gcall *call) > > bool is_strdup =3D gimple_call_builtin_p (call, BUILT_IN_STRDUP); > bool is_strndup =3D gimple_call_builtin_p (call, BUILT_IN_STRNDUP); > + bool is_access_with_size > + =3D gimple_call_internal_p (call, IFN_ACCESS_WITH_SIZE); > if (is_strdup || is_strndup) > bytes =3D strdup_object_size (call, object_size_type, is_strndup); > + else if (is_access_with_size) > + bytes =3D access_with_size_object_size (call, object_size_type); > else > bytes =3D alloc_object_size (call, object_size_type); > > -- > 2.31.1 >