From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dragonfly.birch.relay.mailchannels.net (dragonfly.birch.relay.mailchannels.net [23.83.209.51]) by sourceware.org (Postfix) with ESMTPS id 50257384AB6D for ; Wed, 10 Apr 2024 21:45:18 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 50257384AB6D Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=gotplt.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gotplt.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 50257384AB6D Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=23.83.209.51 ARC-Seal: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1712785529; cv=pass; b=MHVE0zLp7nYbxQ3cqAFHHMXHOZu/O6TSZngHijNzSNli4tDvkaMaOmOn7GWVS5uwkLTbLqoxyKn5liSpduzs4rtlTJra+S111HEqUMvEa3vpxZl5W1+/FrFRevIG+fUoT4gryAr2cHl21uiczU13oVimCYs9/f4rxEnm9MbmiIs= ARC-Message-Signature: i=2; a=rsa-sha256; d=sourceware.org; s=key; t=1712785529; c=relaxed/simple; bh=d8m2ZkrGZmhd1wpuNYOtIGvDVBL6qW8vvbNV+6TuUU8=; h=DKIM-Signature:Message-ID:Date:MIME-Version:Subject:To:From; b=M9ubBhgjjOvVRifIEe5sPGz4XsmFd9ckv769BngyvfiVjx+SuwL7PkAxrKKzolkYZZRGOa7bNA6bnvaEXOlWXwZ0GhipsIp1xmMq/N+RdAGhFHAtbZWeCsGD9hS8rK3DXpaBmv5ldahORpOGQB/6cNW9cVIoBJQQmdfT3TeG4EY= ARC-Authentication-Results: i=2; server2.sourceware.org X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from relay.mailchannels.net (localhost [127.0.0.1]) by relay.mailchannels.net (Postfix) with ESMTP id 5A8D5940134; Wed, 10 Apr 2024 21:45:14 +0000 (UTC) Received: from pdx1-sub0-mail-a300.dreamhost.com (unknown [127.0.0.6]) (Authenticated sender: dreamhost) by relay.mailchannels.net (Postfix) with ESMTPA id 8299A940494; Wed, 10 Apr 2024 21:45:13 +0000 (UTC) ARC-Seal: i=1; s=arc-2022; d=mailchannels.net; t=1712785513; a=rsa-sha256; cv=none; b=A90vGhLedqr/1E6n0e8D6O9YgPeC0/7wGtcLILhf/zgo/+j4DhEozyyN6ohO4bC+FZc+i/ vs5Zw/B3l46fHhZsvrv4PEkhPrh4qcNOWB0DcbtxIjxojYGSUvlBgu6PrqY3XXzKn6yuRe R9eWU3mubhpDY5REcryRNCF+kIri+Q4j/CejYziKpvWpncyeiow0LzDbuHILYx2ckgJXTB bgU8DeVTL01DLjlcW2Ho2ZPzX9h8Xj1/V0B7c0V2twNkpIHls6PbZ0fnXlXv2vNntkZhxQ /2/VyW19B7ktsWTEsaXCLsRuYzWH64RKx9Uv5p0nA8TiW6QYMx5OUCbWGs+H1w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=mailchannels.net; s=arc-2022; t=1712785513; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=yahdE7/CoBg3UUsD9PwVSd+p2YqGfFT9Z7PBhDdhHQI=; b=DJkPqzP66QRLl6ceoKWwQZ/rEQaiGEZE5uwYmANoqBRHA8CUkRRXp8nxszq1M1nQzHoSH2 aYx5Q7EJw+/c9uHc3RJV0zzacwyPw27Mqyai9qzc2oZQFE808dpv52WRVoMwL1CB+5eTO6 JKyVf/A8gOi1G9o/kR8fYMPfLgAgIUKHaBhw9/A6HMbXYrU9Bt1n7uD7A42Sq9L4HJ1su+ 3fNSrRGlK5Ek5i3jvaCRWEYAr/GVGy9D5Unvuj9Xe9fYwBuB9WVxVxiLyECtyK+4BvFN/s PdvtfmMFHErGA3wkyQ7WZa9FeqOUKgfpDlX3ZC/33SMtSwc98Zh3FiviSKVLSg== ARC-Authentication-Results: i=1; rspamd-6f64594bc9-2499p; auth=pass smtp.auth=dreamhost smtp.mailfrom=siddhesh@gotplt.org X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org X-MC-Relay: Neutral X-MailChannels-SenderId: dreamhost|x-authsender|siddhesh@gotplt.org X-MailChannels-Auth-Id: dreamhost X-Hysterical-Harmony: 38ee574d034af835_1712785513851_48924944 X-MC-Loop-Signature: 1712785513851:3638368430 X-MC-Ingress-Time: 1712785513851 Received: from pdx1-sub0-mail-a300.dreamhost.com (pop.dreamhost.com [64.90.62.162]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384) by 100.111.183.125 (trex/6.9.2); Wed, 10 Apr 2024 21:45:13 +0000 Received: from [192.168.0.182] (bras-base-toroon4859w-grc-87-216-209-248-251.dsl.bell.ca [216.209.248.251]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: siddhesh@gotplt.org) by pdx1-sub0-mail-a300.dreamhost.com (Postfix) with ESMTPSA id 4VFGZw5dm3z19H; Wed, 10 Apr 2024 14:45:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gotplt.org; s=dreamhost; t=1712785513; bh=yahdE7/CoBg3UUsD9PwVSd+p2YqGfFT9Z7PBhDdhHQI=; h=Date:Subject:To:Cc:From:Content-Type:Content-Transfer-Encoding; b=K7Ai/DkmeOMmBFIaqxjhkqrHZ/kbPY9Emy1cPyGsRRyTtWYXK8gJfi+lBatPwOx8R nGiH0LE3EJuho8Oqw55ZERszH3Sf343KvcZTtgLRe95RNY380Mgg34twKpK7ZsAoSW cXefOKgyxkNREZAm+2/Xk5Mw5tliMfdjzElcLQYN78GR9Yr210kyJ6YLX9dR45vZSw BjaxKGZuEbo+5rAfwJ+37vWsB+LvHTdUhuO+accWLig08ydq29G9YaKR/s762pz+kP JTwHZ8v5eHuPNfP9PPNUd6PPKCSf2VBajrXjcp6RCUa+MTQmvAGsm8kDqb1aZLAKdx xKnXCFTrec/fw== Message-ID: <857967f8-affb-4d43-b1f7-2078237a33b8@gotplt.org> Date: Wed, 10 Apr 2024 17:45:09 -0400 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v8 3/5] Use the .ACCESS_WITH_SIZE in builtin object size. To: Qing Zhao , josmyers@redhat.com, richard.guenther@gmail.com, uecker@tugraz.at Cc: keescook@chromium.org, isanbard@gmail.com, gcc-patches@gcc.gnu.org References: <20240329160703.4012941-1-qing.zhao@oracle.com> <20240329160703.4012941-4-qing.zhao@oracle.com> Content-Language: en-US From: Siddhesh Poyarekar In-Reply-To: <20240329160703.4012941-4-qing.zhao@oracle.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit X-Spam-Status: No, score=-3035.9 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP 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 2024-03-29 12:07, Qing Zhao wrote: > gcc/ChangeLog: > > * tree-object-size.cc (access_with_size_object_size): New function. > (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. This version looks fine to me for stage 1, but I'm not a maintainer so you'll need an ack from one to commit. Thanks, Sid > --- > .../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/testsuite/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 = 0; > __builtin_abort (); \ > return 0; \ > } while (0) > + > +#define EXPECT(p, _v) do { \ > + size_t v = _v; \ > + if (p == v) \ > + __builtin_printf ("ok: %s == %zd\n", #p, p); \ > + else \ > + { \ > + __builtin_printf ("WAT: %s == %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/testsuite/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_count) > +{ > + array_flex > + = (struct flex *)malloc (sizeof (struct flex) > + + normal_count * sizeof (int)); > + array_flex->b = normal_count; > + > + array_annotated > + = (struct annotated *)malloc (sizeof (struct annotated) > + + attr_count * sizeof (int)); > + array_annotated->b = attr_count; > + > + array_nested_annotated > + = (struct nested_annotated *)malloc (sizeof (struct nested_annotated) > + + attr_count * sizeof (int)); > + array_nested_annotated->b = 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/testsuite/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=3" } */ > + > +#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 pointer > + does not say anything about the object it points to, > + So, __builtin_object_size can not directly use the type of the pointee > + 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 routine) > + 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 allocation > + 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 > + = MAX (sizeof (struct annotated), > + (__builtin_offsetof (struct annotated, array[0]) > + + (index + SIZE_BUMP) * sizeof (char))); > + p = (struct annotated *) malloc (allocated_size); > + > + p->foo = 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 allocation. > + So, the object size info can only been obtained from the call to malloc. > + For both MAXIMUM and MINIMUM: A = (index + SIZE_BUMP) * sizeof (char) */ > + 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 > + = MAX (sizeof (struct annotated), > + (__builtin_offsetof (struct annotated, array[0]) > + + (index) * sizeof (char))); > + p = (struct annotated *) malloc (allocated_size); > + > + p->foo = 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 = alloc_buf_more (10); > + q = 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(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 have no observed allocation nor observed > + 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(char)); > + EXPECT(__builtin_dynamic_object_size(q->array, 1), q->foo * sizeof(char)); > + EXPECT(__builtin_dynamic_object_size(q->array, 2), q->foo * sizeof(char)); > + EXPECT(__builtin_dynamic_object_size(q->array, 3), q->foo * sizeof(char)); > + /* When checking the pointer p, we have no observed allocation nor observed > + 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/testsuite/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 > + = (struct annotated *)malloc (sizeof (struct annotated)); > + array_annotated->b = attr_count; > + > + array_nested_annotated > + = (struct nested_annotated *)malloc (sizeof (struct nested_annotated)); > + array_nested_annotated->b = 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 = 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, const_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 of > + 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 represents > + 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 call, > + 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) == 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 = gimple_call_return_type (call); > + gcc_assert (POINTER_TYPE_P (result_type)); > + tree element_size = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (result_type))); > + tree ref_to_size = gimple_call_arg (call, 1); > + unsigned int class_of_size = TREE_INT_CST_LOW (gimple_call_arg (call, 2)); > + tree type = TREE_TYPE (gimple_call_arg (call, 3)); > + > + tree size = 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 = fold_build2 (LT_EXPR, boolean_type_node, > + unshare_expr (size), build_zero_cst (type)); > + size = fold_build3 (COND_EXPR, integer_type_node, cond_expr, > + build_zero_cst (type), size); > + } > + > + if (class_of_size == 1) > + size = size_binop (MULT_EXPR, > + fold_convert (sizetype, size), > + fold_convert (sizetype, element_size)); > + else > + size = fold_convert (sizetype, size); > + > + if (!todo) > + todo = 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, tree ptr, gcall *call) > > bool is_strdup = gimple_call_builtin_p (call, BUILT_IN_STRDUP); > bool is_strndup = gimple_call_builtin_p (call, BUILT_IN_STRNDUP); > + bool is_access_with_size > + = gimple_call_internal_p (call, IFN_ACCESS_WITH_SIZE); > if (is_strdup || is_strndup) > bytes = strdup_object_size (call, object_size_type, is_strndup); > + else if (is_access_with_size) > + bytes = access_with_size_object_size (call, object_size_type); > else > bytes = alloc_object_size (call, object_size_type); >