| Message ID | 20240910135153.2371650-1-qing.zhao@oracle.com |
|---|---|
| State | New |
| Headers | show |
| Series | [v2] Provide new GCC builtin __builtin_counted_by_ref [PR116016] | expand |
Am Dienstag, dem 10.09.2024 um 13:51 +0000 schrieb Qing Zhao: > #define alloc(P, FAM, COUNT) ({ \ > typeof(P) __p; \ > size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ > __p = kmalloc(__size, GFP); \ > typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ > void *: (size_t *)NULL, \ > default: __builtin_counted_by_ref(__p->FAM))) \ > ret = __builtin_counted_by_ref(__p->FAM); \ > if (ret) \ > *ret = COUNT; \ > P = __p; \ > }) Maybe not too relevant for your patch, but I would use something like this #define alloc(P, FAM, COUNT) ({ \ __auto_type __p = &(P); \ __auto_type __c = (COUNT); \ size_t __size = sizeof(*(*__p)) + sizeof(*(*__p)->FAM) * __c; \ if ((*__p = malloc(__size))) { \ __auto_type ret = __builtin_counted_by_ref((*__p)->FAM); \ *_Generic(ret, void *: &(size_t){0}, default: ret) = __c; \ } \ }) to have brackets around the macro arguments to avoid accidents, to reduce compile time due to multiple evaluation of the macro arguments, and to avoid warnings for the null pointer dereference on clang. (Actually, I would also cast the sizes to a signed type immediately to catch overflows with UBSan, but I kept size_t here.) Martin
Thanks a lot for the tips. I updated the 2 testing cases per your suggestion, they work well. I will send the 3rd version of the patch soon. Qing > On Sep 10, 2024, at 11:42, Martin Uecker <uecker@tugraz.at> wrote: > > Am Dienstag, dem 10.09.2024 um 13:51 +0000 schrieb Qing Zhao: >> #define alloc(P, FAM, COUNT) ({ \ >> typeof(P) __p; \ >> size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ >> __p = kmalloc(__size, GFP); \ >> typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ >> void *: (size_t *)NULL, \ >> default: __builtin_counted_by_ref(__p->FAM))) \ >> ret = __builtin_counted_by_ref(__p->FAM); \ >> if (ret) \ >> *ret = COUNT; \ >> P = __p; \ >> }) > > Maybe not too relevant for your patch, but I would use > something like this > > #define alloc(P, FAM, COUNT) ({ \ > __auto_type __p = &(P); \ > __auto_type __c = (COUNT); \ > size_t __size = sizeof(*(*__p)) + sizeof(*(*__p)->FAM) * __c; \ > if ((*__p = malloc(__size))) { \ > __auto_type ret = __builtin_counted_by_ref((*__p)->FAM); \ > *_Generic(ret, void *: &(size_t){0}, default: ret) = __c; \ > } \ > }) > > to have brackets around the macro arguments to avoid accidents, > to reduce compile time due to multiple evaluation of the macro > arguments, and to avoid warnings for the null pointer dereference > on clang. > > (Actually, I would also cast the sizes to a signed type > immediately to catch overflows with UBSan, but I kept > size_t here.) > > Martin > >
On Tue, Sep 10, 2024 at 06:02:45PM +0000, Qing Zhao wrote: > > #define alloc(P, FAM, COUNT) ({ \ > > __auto_type __p = &(P); \ > > __auto_type __c = (COUNT); \ > > size_t __size = sizeof(*(*__p)) + sizeof(*(*__p)->FAM) * __c; \ Shouldn't that be size_t __size = offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c; \ ? > > if ((*__p = malloc(__size))) { \ > > __auto_type ret = __builtin_counted_by_ref((*__p)->FAM); \ > > *_Generic(ret, void *: &(size_t){0}, default: ret) = __c; \ > > } \ > > }) > > > > to have brackets around the macro arguments to avoid accidents, > > to reduce compile time due to multiple evaluation of the macro > > arguments, and to avoid warnings for the null pointer dereference > > on clang. Jakub
> On Sep 10, 2024, at 14:09, Jakub Jelinek <jakub@redhat.com> wrote: > > On Tue, Sep 10, 2024 at 06:02:45PM +0000, Qing Zhao wrote: >>> #define alloc(P, FAM, COUNT) ({ \ >>> __auto_type __p = &(P); \ >>> __auto_type __c = (COUNT); \ >>> size_t __size = sizeof(*(*__p)) + sizeof(*(*__p)->FAM) * __c; \ > > Shouldn't that be > size_t __size = offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c; \ > ? Yeah, I think that the correct size computation should be: #define MAX(A, B) (A > B) ? (A) : (B) size_t __size = MAX (sizeof (*(*__p)), offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c); \ Qing > >>> if ((*__p = malloc(__size))) { \ >>> __auto_type ret = __builtin_counted_by_ref((*__p)->FAM); \ >>> *_Generic(ret, void *: &(size_t){0}, default: ret) = __c; \ >>> } \ >>> }) >>> >>> to have brackets around the macro arguments to avoid accidents, >>> to reduce compile time due to multiple evaluation of the macro >>> arguments, and to avoid warnings for the null pointer dereference >>> on clang. > > Jakub >
On Tue, Sep 10, 2024 at 06:31:23PM +0000, Qing Zhao wrote: > > > > On Sep 10, 2024, at 14:09, Jakub Jelinek <jakub@redhat.com> wrote: > > > > On Tue, Sep 10, 2024 at 06:02:45PM +0000, Qing Zhao wrote: > >>> #define alloc(P, FAM, COUNT) ({ \ > >>> __auto_type __p = &(P); \ > >>> __auto_type __c = (COUNT); \ > >>> size_t __size = sizeof(*(*__p)) + sizeof(*(*__p)->FAM) * __c; \ > > > > Shouldn't that be > > size_t __size = offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c; \ > > ? > > Yeah, I think that the correct size computation should be: > > #define MAX(A, B) (A > B) ? (A) : (B) > size_t __size = MAX (sizeof (*(*__p)), offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c); \ No, why? sizeof (*(*__p)) should be always >= offsetof(__typeof(*__p), FAM), you can't have an offset outside of a structure (ok, except doing something like use fld[100] as FAM). offsetof + sizeof (elt) * count is the actually needed size, say if it is struct S { size_t a; char b; __attribute__((counted_by (a))) char c[]; }; then you don't really need 2 * sizeof (size_t) + N size of N elements in the flexible array, just sizeof (size_t) + 1 + N is enough. Or is counted_by attribute handling it in some weird way? Jakub
Am Dienstag, dem 10.09.2024 um 20:36 +0200 schrieb Jakub Jelinek: > On Tue, Sep 10, 2024 at 06:31:23PM +0000, Qing Zhao wrote: > > > > > > > On Sep 10, 2024, at 14:09, Jakub Jelinek <jakub@redhat.com> wrote: > > > > > > On Tue, Sep 10, 2024 at 06:02:45PM +0000, Qing Zhao wrote: > > > > > #define alloc(P, FAM, COUNT) ({ \ > > > > > __auto_type __p = &(P); \ > > > > > __auto_type __c = (COUNT); \ > > > > > size_t __size = sizeof(*(*__p)) + sizeof(*(*__p)->FAM) * __c; \ > > > > > > Shouldn't that be > > > size_t __size = offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c; \ > > > ? > > > > Yeah, I think that the correct size computation should be: > > > > #define MAX(A, B) (A > B) ? (A) : (B) > > size_t __size = MAX (sizeof (*(*__p)), offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c); \ > > No, why? sizeof (*(*__p)) should be always >= offsetof(__typeof(*__p), FAM), > you can't have an offset outside of a structure (ok, except doing something > like use fld[100] as FAM). offsetof + sizeof (elt) * count is the actually > needed size, say if it is (offset + sizeof * c) could be smaller than sizeof (*(*__p))). Martin > struct S { size_t a; char b; __attribute__((counted_by (a))) char c[]; }; > then you don't really need 2 * sizeof (size_t) + N size of N elements > in the flexible array, just sizeof (size_t) + 1 + N is enough. > > Or is counted_by attribute handling it in some weird way? > > Jakub >
> On Sep 10, 2024, at 14:48, Martin Uecker <uecker@tugraz.at> wrote: > > Am Dienstag, dem 10.09.2024 um 20:36 +0200 schrieb Jakub Jelinek: >> On Tue, Sep 10, 2024 at 06:31:23PM +0000, Qing Zhao wrote: >>> >>> >>>> On Sep 10, 2024, at 14:09, Jakub Jelinek <jakub@redhat.com> wrote: >>>> >>>> On Tue, Sep 10, 2024 at 06:02:45PM +0000, Qing Zhao wrote: >>>>>> #define alloc(P, FAM, COUNT) ({ \ >>>>>> __auto_type __p = &(P); \ >>>>>> __auto_type __c = (COUNT); \ >>>>>> size_t __size = sizeof(*(*__p)) + sizeof(*(*__p)->FAM) * __c; \ >>>> >>>> Shouldn't that be >>>> size_t __size = offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c; \ >>>> ? >>> >>> Yeah, I think that the correct size computation should be: >>> >>> #define MAX(A, B) (A > B) ? (A) : (B) >>> size_t __size = MAX (sizeof (*(*__p)), offsetof(__typeof(*__p), FAM) + sizeof(*(*__p)->FAM) * __c); \ >> >> No, why? sizeof (*(*__p)) should be always >= offsetof(__typeof(*__p), FAM), >> you can't have an offset outside of a structure (ok, except doing something >> like use fld[100] as FAM). offsetof + sizeof (elt) * count is the actually >> needed size, say if it is > > (offset + sizeof * c) could be smaller than sizeof (*(*__p))). Yes, that’s the reason. [ ~]$ cat t.c #include <stdio.h> #include <stddef.h> struct flex { int b; char other; char c[]; } *array_annotated; int main () { printf ("the size of struct is %d \n", sizeof(struct flex)); printf ("the offset of c is %d \n", offsetof(struct flex, c)); return 0; } [ ~]$ gcc t.c; ./a.out the size of struct is 8 the offset of c is 5 Then if we only allocate 2 elements for the FAM “c”, then offset + sizeof (char) * 2 = 5 + 2 = 7, which is smaller than sizeof (struct flex), 8. Qing > > Martin > > >> struct S { size_t a; char b; __attribute__((counted_by (a))) char c[]; }; >> then you don't really need 2 * sizeof (size_t) + N size of N elements >> in the flexible array, just sizeof (size_t) + 1 + N is enough. >> >> Or is counted_by attribute handling it in some weird way? > >> >> Jakub >> >
diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc index e7e371fd26f..15b90bae8b5 100644 --- a/gcc/c-family/c-common.cc +++ b/gcc/c-family/c-common.cc @@ -430,6 +430,7 @@ const struct c_common_resword c_common_reswords[] = { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY }, { "__builtin_complex", RID_BUILTIN_COMPLEX, D_CONLY }, { "__builtin_convertvector", RID_BUILTIN_CONVERTVECTOR, 0 }, + { "__builtin_counted_by_ref", RID_BUILTIN_COUNTED_BY_REF, D_CONLY }, { "__builtin_has_attribute", RID_BUILTIN_HAS_ATTRIBUTE, 0 }, { "__builtin_launder", RID_BUILTIN_LAUNDER, D_CXXONLY }, { "__builtin_shuffle", RID_BUILTIN_SHUFFLE, 0 }, diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 027f077d51b..4400d2c5d43 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -110,6 +110,7 @@ enum rid RID_TYPES_COMPATIBLE_P, RID_BUILTIN_COMPLEX, RID_BUILTIN_SHUFFLE, RID_BUILTIN_SHUFFLEVECTOR, RID_BUILTIN_CONVERTVECTOR, RID_BUILTIN_TGMATH, RID_BUILTIN_HAS_ATTRIBUTE, RID_BUILTIN_ASSOC_BARRIER, RID_BUILTIN_STDC, + RID_BUILTIN_COUNTED_BY_REF, RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128, /* TS 18661-3 keywords, in the same sequence as the TI_* values. */ diff --git a/gcc/c/c-decl.cc b/gcc/c/c-decl.cc index aa7f69d1b7b..1145dde9bb1 100644 --- a/gcc/c/c-decl.cc +++ b/gcc/c/c-decl.cc @@ -11788,6 +11788,7 @@ names_builtin_p (const char *name) case RID_BUILTIN_SHUFFLE: case RID_BUILTIN_SHUFFLEVECTOR: case RID_BUILTIN_STDC: + case RID_BUILTIN_COUNTED_BY_REF: case RID_CHOOSE_EXPR: case RID_OFFSETOF: case RID_TYPES_COMPATIBLE_P: diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc index aff5af17430..0feddf72f95 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -10647,6 +10647,35 @@ c_parser_predefined_identifier (c_parser *parser) return expr; } +/* Check whether the ARRAY_REF has an counted-by object associated with it + through the "counted_by" attribute. */ +static bool +has_counted_by_object (tree array_ref) +{ + /* Currently, only when the array_ref is an indirect_ref to a call to the + .ACCESS_WITH_SIZE, return true. + More cases can be included later when the counted_by attribute is + extended to other situations. */ + if ((TREE_CODE (array_ref) == INDIRECT_REF) + && is_access_with_size_p (TREE_OPERAND (array_ref, 0))) + return true; + return false; +} + +/* Get the reference to the counted-by object associated with the ARRAY_REF. */ +static tree +get_counted_by_ref (tree array_ref) +{ + /* Currently, only when the array_ref is an indirect_ref to a call to the + .ACCESS_WITH_SIZE, get the corresponding counted_by ref. + More cases can be included later when the counted_by attribute is + extended to other situations. */ + if ((TREE_CODE (array_ref) == INDIRECT_REF) + && is_access_with_size_p (TREE_OPERAND (array_ref, 0))) + return CALL_EXPR_ARG (TREE_OPERAND (array_ref, 0), 1); + return NULL_TREE; +} + /* Parse a postfix expression (C90 6.3.1-6.3.2, C99 6.5.1-6.5.2, C11 6.5.1-6.5.2). Compound literals aren't handled here; callers have to call c_parser_postfix_expression_after_paren_type on encountering them. @@ -11741,6 +11770,54 @@ c_parser_postfix_expression (c_parser *parser) set_c_expr_source_range (&expr, loc, close_paren_loc); break; } + case RID_BUILTIN_COUNTED_BY_REF: + { + vec<c_expr_t, va_gc> *cexpr_list; + c_expr_t *e_p; + location_t close_paren_loc; + + in_builtin_counted_by_ref = true; + + c_parser_consume_token (parser); + if (!c_parser_get_builtin_args (parser, + "__builtin_counted_by_ref", + &cexpr_list, false, + &close_paren_loc)) + { + expr.set_error (); + goto error_exit; + } + if (vec_safe_length (cexpr_list) != 1) + { + error_at (loc, "wrong number of arguments to " + "%<__builtin_counted_by_ref%>"); + expr.set_error (); + goto error_exit; + } + + e_p = &(*cexpr_list)[0]; + + if (TREE_CODE (TREE_TYPE (e_p->value)) != ARRAY_TYPE) + { + error_at (loc, "the argument must be an array" + "%<__builtin_counted_by_ref%>"); + expr.set_error (); + goto error_exit; + } + + if (has_counted_by_object ((*cexpr_list)[0].value)) + expr.value + = get_counted_by_ref ((*cexpr_list)[0].value); + else + expr.value + = build_int_cst (build_pointer_type (void_type_node), 0); + + set_c_expr_source_range (&expr, loc, close_paren_loc); + +error_exit: + in_builtin_counted_by_ref = false; + break; + } case RID_BUILTIN_SHUFFLE: { vec<c_expr_t, va_gc> *cexpr_list; diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h index 57befb94c08..1e8a090d3b6 100644 --- a/gcc/c/c-tree.h +++ b/gcc/c/c-tree.h @@ -737,6 +737,7 @@ extern int c_type_dwarf_attribute (const_tree, int); extern int in_alignof; extern int in_sizeof; extern int in_typeof; +extern bool in_builtin_counted_by_ref; extern bool c_in_omp_for; extern bool c_omp_array_section_p; diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc index 58b2724b39e..ed9444e2077 100644 --- a/gcc/c/c-typeck.cc +++ b/gcc/c/c-typeck.cc @@ -74,6 +74,9 @@ int in_sizeof; /* The level of nesting inside "typeof". */ int in_typeof; +/* inside "builtin_counted_by_ref". */ +bool in_builtin_counted_by_ref; + /* True when parsing OpenMP loop expressions. */ bool c_in_omp_for; @@ -2848,7 +2851,9 @@ build_component_ref (location_t loc, tree datum, tree component, bool use_datum_quals; tree counted_by_type = NULL_TREE; /* Do not handle counted_by when in typeof and alignof operator. */ - handle_counted_by = handle_counted_by && !in_typeof && !in_alignof; + handle_counted_by = handle_counted_by + && !(in_typeof && !in_builtin_counted_by_ref) + && !in_alignof; tree counted_by_ref = handle_counted_by ? build_counted_by_ref (datum, subdatum, &counted_by_type) diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index 2d795ba7e59..268e50677d7 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -15287,6 +15287,61 @@ initializers of variables usable in constant expressions. For more details refer to the latest revision of the C++ standard. @enddefbuiltin +@defbuiltin{@var{type} __builtin_counted_by_ref (@var{ptr})} +The built-in function @code{__builtin_counted_by_ref} checks whether the array +object pointed by the pointer @var{ptr} has another object associated with it +that represents the number of elements in the array object through the +@code{counted_by} attribute (i.e. the counted-by object). If so, returns a +pointer to the corresponding counted-by object. +If such counted-by object does not exist, returns a NULL pointer. + +This built-in function is only available in C for now. + +The argument @var{ptr} must be a pointer to an array. +The @var{type} of the returned value must be a pointer type pointing to the +corresponding type of the counted-by object or a VOID pointer type in case +of a NULL pointer being returned. + +For example: + +@smallexample +struct foo1 @{ + int counter; + struct bar1 array[] __attribute__((counted_by (counter))); +@} *p; + +struct foo2 @{ + int other; + struct bar2 array[]; +@} *q; +@end smallexample + +@noindent +the following call to the built-in + +@smallexample +__builtin_counted_by_ref (p->array) +@end smallexample + +@noindent +returns: + +@smallexample +&p->counter with type @code{int *}. +@end smallexample + +@noindent +However, the following call to the built-in + +@smallexample +__builtin_counted_by_ref (q->array) +@end smallexample + +@noindent +returns a void NULL pointer. + +@enddefbuiltin + @defbuiltin{void __builtin_clear_padding (@var{ptr})} The built-in function @code{__builtin_clear_padding} function clears padding bits inside of the object representation of object pointed by diff --git a/gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c b/gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c new file mode 100644 index 00000000000..0939708510a --- /dev/null +++ b/gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c @@ -0,0 +1,97 @@ +/* Test the code generation for the new __builtin_counted_by_ref. */ +/* { dg-do run } */ +/* { dg-options "-O2" } */ +#include <stdio.h> + +struct annotated { + char b; + int c[] __attribute ((counted_by (b))); +} *array_annotated; + +struct flex { + short b; + int c[]; +} *array_flex; + +struct nested_annotated { + struct { + union { + int b; + float f; + }; + int n; + }; + char c[] __attribute__ ((counted_by (b))); +} *array_nested_annotated; + +struct nested_flex { + struct { + union { + unsigned int b; + float f; + }; + int n; + }; + char c[]; +} *array_nested_flex; + +#define MY_ALLOC(P, FAM, COUNT) ({ \ + typeof(P) __p; \ + size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ + __p = (typeof(P)) __builtin_malloc(__size); \ + __builtin_memset(__p, 0, __size); \ + typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ + void *: (size_t *)NULL, \ + default: __builtin_counted_by_ref(__p->FAM))) \ + ret = __builtin_counted_by_ref(__p->FAM); \ + if (ret) \ + *ret = COUNT; \ + if (sizeof (__builtin_counted_by_ref (__p->FAM)) != sizeof (char *)) \ + __builtin_abort (); \ + P = __p; \ +}) + +int count; + +int main(int argc, char *argv[]) +{ + MY_ALLOC(array_annotated, c, 10); + if (array_annotated->b != 10) + __builtin_abort (); + + MY_ALLOC(array_flex, c, 20); + if (array_flex->b == 20) + __builtin_abort (); + + MY_ALLOC(array_nested_annotated, c, 30); + if (array_nested_annotated->b != 30) + __builtin_abort (); + + MY_ALLOC(array_nested_flex, c, 40); + if (array_nested_flex->b == 40) + __builtin_abort (); + + count = array_annotated->b * 2 + array_nested_annotated->b * 3; + struct annotated * annotated_p; + struct flex * flex_p; + struct nested_annotated * nested_annotated_p; + struct nested_flex * nested_flex_p; + + MY_ALLOC(annotated_p, c, count); + if (annotated_p->b != count) + __builtin_abort (); + + MY_ALLOC(flex_p, c, count * 2); + if (flex_p->b == count * 2) + __builtin_abort (); + + MY_ALLOC(nested_annotated_p, c, count * 3); + if (nested_annotated_p->b != count * 3) + __builtin_abort (); + + MY_ALLOC(nested_flex_p, c, count * 4); + if (nested_flex_p->b == count * 4) + __builtin_abort (); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/builtin-counted-by-ref.c b/gcc/testsuite/gcc.dg/builtin-counted-by-ref.c new file mode 100644 index 00000000000..78650a5d20e --- /dev/null +++ b/gcc/testsuite/gcc.dg/builtin-counted-by-ref.c @@ -0,0 +1,58 @@ +/* Testing the correct usage of the new __builtin_counted_by_ref. */ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +#include <stdio.h> + +struct annotated { + size_t b; + int other; + int c[] __attribute ((counted_by (b))); +} *array_annotated; + +struct flex { + size_t b; + int other; + int c[]; +} *array_flex; + +#define MY_ALLOC(P, FAM, COUNT) ({ \ + typeof(P) __p; \ + size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ + __p = (typeof(P)) __builtin_malloc(__size); \ + typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ + void *: (size_t *)NULL, \ + default: __builtin_counted_by_ref(__p->FAM))) \ + ret = __builtin_counted_by_ref(__p->FAM); \ + if (ret) \ + *ret = COUNT; \ + P = __p; \ +}) + +extern char c_count; +extern short s_count; +extern int i_count; +extern long l_count; +extern float f_count; + +extern int * foo (); + +int main(int argc, char *argv[]) +{ + /* The good usages. */ + MY_ALLOC(array_annotated, c, 10); + MY_ALLOC(array_flex, c, 20); + MY_ALLOC(array_annotated, c, c_count); + MY_ALLOC(array_flex, c, i_count); + MY_ALLOC(array_annotated, c, l_count); + MY_ALLOC(array_flex, c, c_count * 3); + MY_ALLOC(array_annotated, c, l_count * i_count); + + /* The bad usages, issue errors. */ + __builtin_counted_by_ref (); /* { dg-error "wrong number of arguments to" } */ + __builtin_counted_by_ref (array_annotated->c, 10); /* { dg-error "wrong number of arguments to" } */ + __builtin_counted_by_ref (array_annotated->other); /* { dg-error "the argument must be an array" } */ + __builtin_counted_by_ref (foo()); /* { dg-error "the argument must be an array" } */ + + return 0; +}
Hi, This is the 2nd version of the patch after the long discussion. We finally decided to keep the previous design that returns a pointer to the counted_by object. Compared to the first version, the major changes are: 1. change the name of the builtin from __builtin_get_counted_by to __builtin_counted_by_ref in order to reflect the fact that the returned value of it is a reference to the object. 2. make typeof(__builtin_counted_by_ref) working. 3. update the testing case to use the new builtin inside _Generic. bootstrapped and regress tested on both X86 and aarch64. no issue. Okay for the trunk? thanks. Qing. ==================================== With the addition of the 'counted_by' attribute and its wide roll-out within the Linux kernel, a use case has been found that would be very nice to have for object allocators: being able to set the counted_by counter variable without knowing its name. For example, given: struct foo { ... int counter; ... struct bar array[] __attribute__((counted_by (counter))); } *p; The existing Linux object allocators are roughly: #define alloc(P, FAM, COUNT) ({ \ typeof(P) __p; \ size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ __p = kmalloc(__size, GFP); \ P = __p; \ }) Right now, any addition of a counted_by annotation must also include an open-coded assignment of the counter variable after the allocation: p = alloc(p, array, how_many); p->counter = how_many; In order to avoid the tedious and error-prone work of manually adding the open-coded counted-by intializations everywhere in the Linux kernel, a new GCC builtin __builtin_counted_by_ref will be very useful to be added to help the adoption of the counted-by attribute. -- Built-in Function: TYPE __builtin_counted_by_ref (PTR) The built-in function '__builtin_counted_by_ref' checks whether the array object pointed by the pointer PTR has another object associated with it that represents the number of elements in the array object through the 'counted_by' attribute (i.e. the counted-by object). If so, returns a pointer to the corresponding counted-by object. If such counted-by object does not exist, returns a NULL pointer. This built-in function is only available in C for now. The argument PTR must be a pointer to an array. The TYPE of the returned value must be a pointer type pointing to the corresponding type of the counted-by object or VOID pointer type in case of a NULL pointer being returned. With this new builtin, the central allocator could be updated to: #define alloc(P, FAM, COUNT) ({ \ typeof(P) __p; \ size_t __size = sizeof(*P) + sizeof(*P->FAM) * COUNT; \ __p = kmalloc(__size, GFP); \ typeof(_Generic(__builtin_counted_by_ref(__p->FAM), \ void *: (size_t *)NULL, \ default: __builtin_counted_by_ref(__p->FAM))) \ ret = __builtin_counted_by_ref(__p->FAM); \ if (ret) \ *ret = COUNT; \ P = __p; \ }) And then structs can gain the counted_by attribute without needing additional open-coded counter assignments for each struct, and unannotated structs could still use the same allocator. PR c/116016 gcc/c-family/ChangeLog: * c-common.cc: Add new __builtin_counted_by_ref. * c-common.h (enum rid): Add RID_BUILTIN_COUNTED_BY_REF. gcc/c/ChangeLog: * c-decl.cc (names_builtin_p): Add RID_BUILTIN_COUNTED_BY_REF. * c-parser.cc (has_counted_by_object): New routine. (get_counted_by_ref): New routine. (c_parser_postfix_expression): Handle New RID_BUILTIN_COUNTED_BY_REF. * c-tree.h: New global in_builtin_counted_by_ref. * c-typeck.cc (build_component_ref): Enable generating .ACCESS_WITH_SIZE inside typeof when inside builtin_counted_by_ref. gcc/ChangeLog: * doc/extend.texi: Add documentation for __builtin_counted_by_ref. gcc/testsuite/ChangeLog: * gcc.dg/builtin-counted-by-ref-1.c: New test. * gcc.dg/builtin-counted-by-ref.c: New test. --- gcc/c-family/c-common.cc | 1 + gcc/c-family/c-common.h | 1 + gcc/c/c-decl.cc | 1 + gcc/c/c-parser.cc | 77 +++++++++++++++ gcc/c/c-tree.h | 1 + gcc/c/c-typeck.cc | 7 +- gcc/doc/extend.texi | 55 +++++++++++ .../gcc.dg/builtin-counted-by-ref-1.c | 97 +++++++++++++++++++ gcc/testsuite/gcc.dg/builtin-counted-by-ref.c | 58 +++++++++++ 9 files changed, 297 insertions(+), 1 deletion(-) create mode 100644 gcc/testsuite/gcc.dg/builtin-counted-by-ref-1.c create mode 100644 gcc/testsuite/gcc.dg/builtin-counted-by-ref.c