cacheflush.2
Subsystems (4)
Hello Michael,
function cacheflush() does not exist on many architectures.
It would have saved me a lot of time if the man-page had referenced GCC's
void __builtin___clear_cache(void *begin, void *end)
Maybe you can add it to NOTES.
Best regards
heirnich
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:
void __builtin___clear_cache(void *begin, void *end);
]
Cheers,
Alex
Quoted 13 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; http://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end);
]
I just checked building with Clang/LLVM. There the arguments are of type (char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign]
+ __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t *' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign]
+ state->ram_buf + state->ram_size);
+ ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Best regards
Heinrich
Quoted 20 lines
Cheers,
Alex
Quoted 13 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Hi Heinrich,
It looks like a bug (or at least an undocumented divergence from GCC) in Clang/LLVM. Or I couldn't find the documentation for it.
Clang uses 'char *':
https://github.com/llvm/llvm-project/blob/7faf62a80bfc3a9dfe34133681fcc31f8e8d658b/clang/include/clang/Basic/Builtins.def#L583
GCC uses 'void *':
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
I CCd Clang and GCC lists; maybe they know about that divergence.
Cheers,
Alex
Quoted 53 lines · Heinrich Schuchardt
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end); ]I just checked building with Clang/LLVM. There the arguments are of type (char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] + __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] +state->ram_buf+state->ram_size); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Best regards
Heinrich
Quoted 21 lines
Cheers,
Alex
Quoted 14 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; http://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
It looks like GCC recently moved from 'char *' to 'void *'. This SO question[1] (4 years ago) quotes the GCC docs and they had 'char *'.
Maybe Clang hasn't noticed the change.
I'll report a bug.
[1]: https://stackoverflow.com/q/35741814/6872717
Quoted 72 lines · Alejandro Colomar (man-pages)
Hi Heinrich,
It looks like a bug (or at least an undocumented divergence from GCC) in Clang/LLVM. Or I couldn't find the documentation for it.
Clang uses 'char *':
https://github.com/llvm/llvm-project/blob/7faf62a80bfc3a9dfe34133681fcc31f8e8d658b/clang/include/clang/Basic/Builtins.def#L583GCC uses 'void *':
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.htmlI CCd Clang and GCC lists; maybe they know about that divergence.
Cheers,
Alex
Quoted 53 lines · Heinrich Schuchardt
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end); ]I just checked building with Clang/LLVM. There the arguments are of type (char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] + __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] +state->ram_buf+state->ram_size); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Best regards
Heinrich
Quoted 21 lines
Cheers,
Alex
Quoted 14 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
Quoted 3 lines · Alejandro Colomar (man-pages) via Gcc
It looks like GCC recently moved from 'char *' to 'void *'. This SO question[1] (4 years ago) quotes the GCC docs and they had 'char *'.
__builtin___clear_cache in GCC has always been declared to take void*. The signature in the manual was recently corrected to match the implementation, i.e., from char* to void*, in r269082.
Martin
Quoted 79 lines
Maybe Clang hasn't noticed the change.
I'll report a bug.[1]: https://stackoverflow.com/q/35741814/6872717
Quoted 72 lines · Alejandro Colomar (man-pages)
Hi Heinrich,
It looks like a bug (or at least an undocumented divergence from GCC) in Clang/LLVM. Or I couldn't find the documentation for it.
Clang uses 'char *':
https://github.com/llvm/llvm-project/blob/7faf62a80bfc3a9dfe34133681fcc31f8e8d658b/clang/include/clang/Basic/Builtins.def#L583GCC uses 'void *':
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.htmlI CCd Clang and GCC lists; maybe they know about that divergence.
Cheers,
Alex
Quoted 53 lines · Heinrich Schuchardt
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end);
]I just checked building with Clang/LLVM. There the arguments are of type (char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] + __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] +state->ram_buf+state->ram_size); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Best regards
Heinrich
Quoted 21 lines
Cheers,
Alex
Quoted 14 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Hello Martin,
Thanks for the correction!
Then the prototypes that changes from 'char *' to 'void *' in r269082 were not exposed to the user, right?
I guess then those are just internal implementation where GCC did use 'char *'.
Where is the actual prototype exposed to the user declared?
Thanks,
Alex
P.S.: Michael, wait for a patch revision (v6).
Quoted 94 lines · Martin Sebor
Quoted 3 lines · Alejandro Colomar (man-pages) via Gcc
It looks like GCC recently moved from 'char *' to 'void *'. This SO question[1] (4 years ago) quotes the GCC docs and they had 'char *'.
__builtin___clear_cachein GCC has always been declared to take void*. The signature in the manual was recently corrected to match the implementation, i.e., from char* to void*, in r269082.Martin
Quoted 82 lines
Maybe Clang hasn't noticed the change.
I'll report a bug.[1]: https://stackoverflow.com/q/35741814/6872717
Quoted 75 lines · Alejandro Colomar (man-pages)
Hi Heinrich,
It looks like a bug (or at least an undocumented divergence from GCC) in Clang/LLVM. Or I couldn't find the documentation for it.
Clang uses 'char *':
https://github.com/llvm/llvm-project/blob/7faf62a80bfc3a9dfe34133681fcc31f8e8d658b/clang/include/clang/Basic/Builtins.def#L583GCC uses 'void *':
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.htmlI CCd Clang and GCC lists; maybe they know about that divergence.
Cheers,
Alex
Quoted 55 lines · Heinrich Schuchardt
Quoted 4 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
Quoted 8 lines
[
NOTES
GCC provides a similar function, which may be useful on archi‐
tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end); ]I just checked building with Clang/LLVM. There the arguments are of type
(char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] + __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] +state->ram_buf+state->ram_size); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Best regards
Heinrich
Quoted 21 lines
Cheers,
Alex
Quoted 14 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
Ping: cacheflush.2
Hi Martin,
I sent you an email, but I received a "delivery failure". If you're reading this from a list, could you answer, please?
Thanks,
Alex
Quoted 112 lines · Alejandro Colomar (man-pages)
Hello Martin,
Thanks for the correction!
Then the prototypes that changes from 'char *' to 'void *' in r269082 were not exposed to the user, right?
I guess then those are just internal implementation where GCC did use 'char *'.Where is the actual prototype exposed to the user declared?
Thanks,
Alex
P.S.: Michael, wait for a patch revision (v6).Quoted 94 lines · Martin Sebor
Quoted 3 lines · Alejandro Colomar (man-pages) via Gcc
It looks like GCC recently moved from 'char *' to 'void *'. This SO question[1] (4 years ago) quotes the GCC docs and they had 'char *'.
__builtin___clear_cachein GCC has always been declared to take void*. The signature in the manual was recently corrected to match the implementation, i.e., from char* to void*, in r269082.Martin
Quoted 82 lines
Maybe Clang hasn't noticed the change.
I'll report a bug.[1]: https://stackoverflow.com/q/35741814/6872717
Quoted 75 lines · Alejandro Colomar (man-pages)
Hi Heinrich,
It looks like a bug (or at least an undocumented divergence from GCC) in Clang/LLVM. Or I couldn't find the documentation for it.
Clang uses 'char *':
https://github.com/llvm/llvm-project/blob/7faf62a80bfc3a9dfe34133681fcc31f8e8d658b/clang/include/clang/Basic/Builtins.def#L583GCC uses 'void *':
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.htmlI CCd Clang and GCC lists; maybe they know about that divergence.
Cheers,
Alex
Quoted 55 lines · Heinrich Schuchardt
Quoted 4 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
Quoted 8 lines
[
NOTES
GCC provides a similar function, which may be useful on archi‐
tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end); ]I just checked building with Clang/LLVM. There the arguments are of type
(char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] + __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] +state->ram_buf+state->ram_size); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Best regards
Heinrich
Quoted 21 lines
Cheers,
Alex
Quoted 14 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es/
Re: Ping: cacheflush.2
Quoted 17 lines · Alejandro Colomar (man-pages)
Hi Martin,
I sent you an email, but I received a "delivery failure". If you're reading this from a list, could you answer, please?
Thanks,
Alex
Quoted 7 lines · Alejandro Colomar (man-pages)
Hello Martin,
Thanks for the correction!
Then the prototypes that changes from 'char *' to 'void *' in r269082 were not exposed to the user, right?
I guess then those are just internal implementation where GCC did use 'char *'.
__builtin___clear_cache was added to GCC in r126535 (the __builtin_ prefix is added by the macro):
+DEF_EXT_LIB_BUILTIN (BUILT_IN_CLEAR_CACHE, "__clear_cache", BT_FN_VOID_PTR_PTR, ATTR_NOTHROW_LIST)
The BT_FN_VOID_PTR_PTR macro describes its signature as returning void and taking two void pointer arguments. AFAIK, this has never changed. Contrary to that, the manual entry for the built-in added in the same revision documented it as taking two char*. That was corrected to void* in r269082 to match.
There's a GCC internal declaration of __clear_cache (apparently provided in libgcc for VxWorks). It was added in r264479 and it also used char*. This was also changed to void* in r269082 to match the built-in. Looks like this __clear_cache has just been removed from libgcc in GCC 11:
https://gcc.gnu.org/pipermail/gcc-cvs/2020-December/338478.html
Quoted 2 lines
Quoted 2 lines
Where is the actual prototype exposed to the user declared?
Built-in functions are declared implicitly by GCC. They have no explicit declarations like user-defined functions. The implicit internal "declarations" are specified in the GCC internal file gcc/builtins.def, where they are hidden behind layers of macros. For example, on the GCC 10 branch, the declaration for __builtin___clear_cache is here:
Martin
Quoted 104 lines
Quoted 103 lines
Thanks,
Alex
P.S.: Michael, wait for a patch revision (v6).Quoted 94 lines · Martin Sebor
Quoted 3 lines · Alejandro Colomar (man-pages) via Gcc
It looks like GCC recently moved from 'char *' to 'void *'. This SO question[1] (4 years ago) quotes the GCC docs and they had 'char *'.
__builtin___clear_cachein GCC has always been declared to take void*. The signature in the manual was recently corrected to match the implementation, i.e., from char* to void*, in r269082.Martin
Quoted 82 lines
Maybe Clang hasn't noticed the change.
I'll report a bug.[1]: https://stackoverflow.com/q/35741814/6872717
Quoted 75 lines · Alejandro Colomar (man-pages)
Hi Heinrich,
It looks like a bug (or at least an undocumented divergence from GCC) in Clang/LLVM. Or I couldn't find the documentation for it.
Clang uses 'char *':
https://github.com/llvm/llvm-project/blob/7faf62a80bfc3a9dfe34133681fcc31f8e8d658b/clang/include/clang/Basic/Builtins.def#L583GCC uses 'void *':
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.htmlI CCd Clang and GCC lists; maybe they know about that divergence.
Cheers,
Alex
Quoted 55 lines · Heinrich Schuchardt
Quoted 4 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
Quoted 8 lines
[
NOTES
GCC provides a similar function, which may be useful on
archi‐
tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end);
]I just checked building with Clang/LLVM. There the arguments are of type
(char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] + __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign] +state->ram_buf+state->ram_size); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Best regards
Heinrich
Quoted 21 lines
Cheers,
Alex
Quoted 14 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced GCC's
void
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Re: Ping: cacheflush.2
Hi Martin,
Thanks! It's good to learn some GCC internal details :)
Cheers,
Alex
Quoted 163 lines · Martin Sebor
Quoted 17 lines · Alejandro Colomar (man-pages)
Hi Martin,
I sent you an email, but I received a "delivery failure". If you're reading this from a list, could you answer, please?
Thanks,
Alex
Quoted 7 lines · Alejandro Colomar (man-pages)
Hello Martin,
Thanks for the correction!
Then the prototypes that changes from 'char *' to 'void *' in r269082 were not exposed to the user, right?
I guess then those are just internal implementation where GCC did use 'char *'.
__builtin___clear_cachewas added to GCC in r126535 (the__builtin_prefix is added by the macro):+DEF_EXT_LIB_BUILTIN (
BUILT_IN_CLEAR_CACHE, "__clear_cache",BT_FN_VOID_PTR_PTR,ATTR_NOTHROW_LIST)The
BT_FN_VOID_PTR_PTRmacro describes its signature as returning void and taking two void pointer arguments. AFAIK, this has never changed. Contrary to that, the manual entry for the built-in added in the same revision documented it as taking two char*. That was corrected to void* in r269082 to match.There's a GCC internal declaration of
__clear_cache(apparently provided in libgcc for VxWorks). It was added in r264479 and it also used char*. This was also changed to void* in r269082 to match the built-in. Looks like this__clear_cachehas just been removed from libgcc in GCC 11:
https://gcc.gnu.org/pipermail/gcc-cvs/2020-December/338478.htmlQuoted 2 lines
Quoted 2 lines
Where is the actual prototype exposed to the user declared?
Built-in functions are declared implicitly by GCC. They have no explicit declarations like user-defined functions. The implicit internal "declarations" are specified in the GCC internal file gcc/builtins.def, where they are hidden behind layers of macros. For example, on the GCC 10 branch, the declaration for
__builtin___clear_cacheis here:Martin
Quoted 109 lines
Quoted 108 lines
Thanks,
Alex
P.S.: Michael, wait for a patch revision (v6).Quoted 99 lines · Martin Sebor
Quoted 3 lines · Alejandro Colomar (man-pages) via Gcc
It looks like GCC recently moved from 'char *' to 'void *'. This SO question[1] (4 years ago) quotes the GCC docs and they had 'char *'.
__builtin___clear_cachein GCC has always been declared to take void*. The signature in the manual was recently corrected to match the implementation, i.e., from char* to void*, in r269082.Martin
Quoted 87 lines
Maybe Clang hasn't noticed the change.
I'll report a bug.[1]: https://stackoverflow.com/q/35741814/6872717
Quoted 80 lines · Alejandro Colomar (man-pages)
Hi Heinrich,
It looks like a bug (or at least an undocumented divergence from GCC) in
Clang/LLVM. Or I couldn't find the documentation for it.Clang uses 'char *':
https://github.com/llvm/llvm-project/blob/7faf62a80bfc3a9dfe34133681fcc31f8e8d658b/clang/include/clang/Basic/Builtins.def#L583GCC uses 'void *':
https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.htmlI CCd Clang and GCC lists; maybe they know about that divergence.
Cheers,
Alex
Quoted 58 lines · Heinrich Schuchardt
Quoted 4 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
Quoted 8 lines
[
NOTES
GCC provides a similar function, which may be useful on archi‐
tectures that lack this system call:void
__builtin___clear_cache(void *begin, void *end); ]I just checked building with Clang/LLVM. There the arguments are of type
(char *). See the following error output:
+arch/sandbox/cpu/cache.c:19:26: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign]
+ __builtin___clear_cache(state->ram_buf,
+ ^~~~~~~~~~~~~~+arch/sandbox/cpu/cache.c:20:12: error: passing 'uint8_t*' (aka 'unsigned char *') to parameter of type 'char *' converts between pointers to integer types with different sign [-Werror,-Wpointer-sign]
+state->ram_buf+state->ram_size); + ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Best regards
Heinrich
Quoted 22 lines
Cheers,
Alex
Quoted 15 lines · Heinrich Schuchardt
Hello Michael,
function
cacheflush()does not exist on many architectures.It would have saved me a lot of time if the man-page had referenced
GCC'svoid
__builtin___clear_cache(void *begin, void *end)Maybe you can add it to NOTES.
Best regards
heirnich
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es/
Quoted 9 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:
Quoted 6 lines
void
__builtin___clear_cache(void *begin, void *end);
]Cheers,
Alex
Maybe we should discourage people from calling the cacheflush syscall?
I think that people shouldn't be using the syscall unless they really need the finer grained control it provides, and are prepared to take a hit to portability.
(On arches where userspace is allowed to do cache flushing directly, __builtin___clear_cache() should transparently do the right thing, with no syscall overhead -- if not, that's probably a bug in the toolchain or compiler support library.)
[...]
Cheers
---Dave
Quoted 19 lines · Dave Martin
Quoted 9 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:Quoted 6 lines
void
__builtin___clear_cache(void *begin, void *end);
]Cheers,
Alex
Maybe we should discourage people from calling the cacheflush syscall?
Quoted 8 lines
I think that people shouldn't be using the syscall unless they really need the finer grained control it provides, and are prepared to take a hit to portability.
(On arches where userspace is allowed to do cache flushing directly,
__builtin___clear_cache()should transparently do the right thing, with no syscall overhead -- if not, that's probably a bug in the toolchain or compiler support library.)
What the compiler builtin does depends on the architecture (e.g. nothing for x86, cacheflush() for MIPS, a private syscall (0xf0002) on ARM, assembly code on ARM64, ...) and on the the operating system (Linux, BSD, OS X). For portable code the builtin is really the best choice.
Best regards
Heinrich
Quoted 6 lines
[...]
Cheers
---Dave
RFC v2: Re: cacheflush.2
Hi all,
v2:
[
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function __builtin___clear_cache(), which provides a more portable interface:
void __builtin___clear_cache(void *begin, void *end);
]
If you like it, I'll send the patch.
BTW, I'll also have a look and document the different prototypes for cacheflush(2).
Thanks,
Alex
Quoted 46 lines · Heinrich Schuchardt
Quoted 20 lines · Dave Martin
Quoted 9 lines · Alejandro Colomar (man-pages)
Hi Heinrich & Michael,
What about the following?:
[
NOTES
GCC provides a similar function, which may be useful on archi‐ tectures that lack this system call:Quoted 6 lines
void
__builtin___clear_cache(void *begin, void *end); ]Cheers,
Alex
Maybe we should discourage people from calling the cacheflush syscall?
Quoted 8 lines
I think that people shouldn't be using the syscall unless they really need the finer grained control it provides, and are prepared to take a hit to portability.
(On arches where userspace is allowed to do cache flushing directly,
__builtin___clear_cache()should transparently do the right thing, with no syscall overhead -- if not, that's probably a bug in the toolchain or compiler support library.)What the compiler builtin does depends on the architecture (e.g. nothing for x86,
cacheflush()for MIPS, a private syscall (0xf0002) on ARM, assembly code on ARM64, ...) and on the the operating system (Linux, BSD, OS X). For portable code the builtin is really the best choice.Best regards
Heinrich
Quoted 6 lines
[...]
Cheers
---Dave
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
Re: RFC v2: Re: cacheflush.2
i Alex,
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi all,
v2:
[
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function__builtin___clear_cache(), which provides a more portable interface:
Quoted 2 lines
void
__builtin___clear_cache(void *begin, void *end);
]
This seems a reasonable text to me, but I think it would be helpful to say a little more precisely what kind of portability we are talking about here.
Greater ortability across Linux architectures? Greater portability across platforms supported by GCC (including non-Linux) platforms? Something else?
Thanks,
Michael
Signature · 3 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/
Re: RFC v2: Re: cacheflush.2
Hi Michael,
Quoted 14 lines · Michael Kerrisk (man-pages)
i Alex,
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi all,
v2:
[
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function__builtin___clear_cache(), which provides a more portable interface:
Quoted 6 lines
Quoted 2 lines
void __builtin___clear_cache(void *begin, void *end);]
This seems a reasonable text to me, but I think it would be helpful to say a little more precisely what kind of portability we are talking about here.
Sure.
Quoted 4 lines
Greater ortability across Linux architectures? Greater portability across platforms supported by GCC (including non-Linux) platforms? Something else?
'... which provides a portable interface across platforms supported by GCC:' sounds good.
Maybe GCC devs have something more to add.
Thanks,
Alex
Quoted 6 lines
Thanks,
Michael
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
RFC v3: Re: cacheflush.2
Hi all,
Please review this text:
[
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function __builtin___clear_cache(), which provides a more portable interface:
void __builtin___clear_cache(void *begin, void *end);
On platforms that don't require instruction cache flushes, __builtin___clear_cache() has no effect.
Note: On some GCC-compatible compilers, such as clang, the prototype for this function uses char * instead of void *.
]
Thanks,
Alex
Quoted 47 lines · Alejandro Colomar (man-pages)
Hi Michael,
Quoted 14 lines · Michael Kerrisk (man-pages)
i Alex,
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi all,
v2:
[
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function__builtin___clear_cache(), which provides a more portable interface:Quoted 6 lines
Quoted 2 lines
void __builtin___clear_cache(void *begin, void *end);]
This seems a reasonable text to me, but I think it would be helpful to say a little more precisely what kind of portability we are talking about here.
Sure.
Quoted 4 lines
Greater ortability across Linux architectures? Greater portability across platforms supported by GCC (including non-Linux) platforms? Something else?
'... which provides a portable interface across platforms supported by GCC:' sounds good.
Maybe GCC devs have something more to add.
Thanks,
Alex
Quoted 6 lines
Thanks,
Michael
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
RFC v4: Re: cacheflush.2
I forgot to add a junk to the text.
v4:
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function __builtin___clear_cache(), which provides a portable interface across platforms supported by GCC and compatible compilers:
//Maybe 'and compatible compilers' is redundant and I should remove it?
void __builtin___clear_cache(void *begin, void *end);
On platforms that don't require instruction cache flushes, __builtin___clear_cache() has no effect.
Note: On some GCC-compatible compilers, such as clang, the prototype for this function uses char * instead of void *.
Quoted 73 lines · Alejandro Colomar (man-pages)
Hi all,
Please review this text:
[
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function__builtin___clear_cache(), which provides a more portable interface:void
__builtin___clear_cache(void *begin, void *end);On platforms that don't require instruction cache flushes,
__builtin___clear_cache()has no effect.Note: On some GCC-compatible compilers, such as clang, the prototype for this function uses char * instead of void *.
]Thanks,
Alex
Quoted 47 lines · Alejandro Colomar (man-pages)
Hi Michael,
Quoted 14 lines · Michael Kerrisk (man-pages)
i Alex,
Quoted 11 lines · Alejandro Colomar (man-pages)
Hi all,
v2:
[
NOTES
Unless you need the finer grained control that this system call provides, you probably want to use the GCC built-in function__builtin___clear_cache(), which provides a more portable interface:Quoted 6 lines
Quoted 2 lines
void __builtin___clear_cache(void *begin, void *end);]
This seems a reasonable text to me, but I think it would be helpful to say a little more precisely what kind of portability we are talking about here.
Sure.
Quoted 4 lines
Greater ortability across Linux architectures? Greater portability across platforms supported by GCC (including non-Linux) platforms? Something else?
'... which provides a portable interface across platforms supported by GCC:' sounds good.
Maybe GCC devs have something more to add.
Thanks,
Alex
Quoted 6 lines
Thanks,
Michael
Signature · 3 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es
PATCH v5 1/1 cacheflush.2: Document __builtin___clear_cache() as a more portable alternative
--- man2/cacheflush.2 | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
man2/cacheflush.2 +24 -0
@@ -86,6 +86,30 @@ On Linux, this call first appeared on the MIPS architecture, but nowadays, Linux provides a .BR cacheflush () system call on some other architectures, but with different arguments. +.SH NOTES +Unless you need the finer grained control that this system call provides, +you probably want to use the GCC built-in function +.BR __builtin___clear_cache (), +which provides a portable interface +across platforms supported by GCC and compatible compilers: +.PP +.in +4n +.EX +.BI "void __builtin___clear_cache(void *" begin ", void *" end ); +.EE +.in +.PP +On platforms that don't require instruction cache flushes, +.BR __builtin___clear_cache () +has no effect. +.PP +.IR Note : +Until GCC 9.1.0, +the prototype for this built-in function used +.I char * +instead of +.I void * +for the parameters. .SH BUGS Linux kernels older than version 2.6.11 ignore the .I addr
Signature · 7 lines
2.29.2 _______________________________________________ linux-snps-arc mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-snps-arc
Re: [PATCH v5] cacheflush.2: Document __builtin___clear_cache() as a more portable alternative
Quoted 2 lines · Alejandro Colomar
Reported-by Heinrich Schuchardt <[email protected]>Signed-off-by Alejandro Colomar <[email protected]>
Quoted 30 lines
--- man2/cacheflush.2 | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)man2/cacheflush.2 +17
-0@@ -86,6 +86,30 @@ On Linux, this call first appeared on the MIPS architecture, but nowadays, Linux provides a .BR cacheflush () system call on some other architectures, but with different arguments. +.SH NOTES +Unless you need the finer grained control that this system call provides, +you probably want to use the GCC built-in function +.BR __builtin___clear_cache (), +which provides a portable interface +across platforms supported by GCC and compatible compilers: +.PP +.in +4n +.EX +.BI "void __builtin___clear_cache(void *" begin ", void *" end ); +.EE +.in +.PP +On platforms that don't require instruction cache flushes, +.BR __builtin___clear_cache () +has no effect. +.PP
man2/cacheflush.2 On Linux, this call first appeared on the MIPS architecture, · line 115
Quoted 10 lines
man2/cacheflush.2 +7
-0+.IR Note : +Until GCC 9.1.0, +the prototype for this built-in function used +.I char * +instead of +.I void * +for the parameters. .SH BUGS Linux kernels older than version 2.6.11 ignore the .I addr
_______________________________________________
linux-snps-arc mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-snps-arc
PATCH v6 1/1 cacheflush.2: Document __builtin___clear_cache() as a more portable alternative
In reply to Alejandro Colomar (man-pages)---
v6:
- GCC has always exposed 'void *', as Martin Sebor noted. It's Clang (and maybe others) that (following GCC's docs) exposed 'char *'.
man2/cacheflush.2 | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)
man2/cacheflush.2 +24 -0
@@ -86,6 +86,30 @@ On Linux, this call first appeared on the MIPS architecture, but nowadays, Linux provides a .BR cacheflush () system call on some other architectures, but with different arguments. +.SH NOTES +Unless you need the finer grained control that this system call provides, +you probably want to use the GCC built-in function +.BR __builtin___clear_cache (), +which provides a portable interface +across platforms supported by GCC and compatible compilers: +.PP +.in +4n +.EX +.BI "void __builtin___clear_cache(void *" begin ", void *" end ); +.EE +.in +.PP +On platforms that don't require instruction cache flushes, +.BR __builtin___clear_cache () +has no effect. +.PP +.IR Note : +On some GCC-compatible compilers, +the prototype for this built-in function uses +.I char * +instead of +.I void * +for the parameters. .SH BUGS Linux kernels older than version 2.6.11 ignore the .I addr
Signature · 7 lines
2.29.2 _______________________________________________ linux-snps-arc mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-snps-arc
Ping: [PATCH v6] cacheflush.2: Document __builtin___clear_cache() as a more portable alternative
Ping
Quoted 50 lines · Alejandro Colomar
Reported-by Heinrich Schuchardt <[email protected]>Signed-off-by Alejandro Colomar <[email protected]>Cc Martin Sebor <[email protected]>Cc Dave Martin <[email protected]>---
v6:
- GCC has always exposed 'void *', as Martin Sebor noted. It's Clang (and maybe others) that (following GCC's docs) exposed 'char *'.man2/cacheflush.2 | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)man2/cacheflush.2 +24
-0@@ -86,6 +86,30 @@ On Linux, this call first appeared on the MIPS architecture, but nowadays, Linux provides a .BR cacheflush () system call on some other architectures, but with different arguments. +.SH NOTES +Unless you need the finer grained control that this system call provides, +you probably want to use the GCC built-in function +.BR __builtin___clear_cache (), +which provides a portable interface +across platforms supported by GCC and compatible compilers: +.PP +.in +4n +.EX +.BI "void __builtin___clear_cache(void *" begin ", void *" end ); +.EE +.in +.PP +On platforms that don't require instruction cache flushes, +.BR __builtin___clear_cache () +has no effect. +.PP +.IR Note : +On some GCC-compatible compilers, +the prototype for this built-in function uses +.I char * +instead of +.I void * +for the parameters. .SH BUGS Linux kernels older than version 2.6.11 ignore the .I addr
Signature · 8 lines
Alejandro Colomar Linux man-pages comaintainer; https://www.kernel.org/doc/man-pages/ http://www.alejandro-colomar.es/ _______________________________________________ linux-snps-arc mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-snps-arc
Re: [PATCH v6] cacheflush.2: Document __builtin___clear_cache() as a more portable alternative
In reply to Alejandro ColomarQuoted 10 lines · Alejandro Colomar
Reported-by Heinrich Schuchardt <[email protected]>Signed-off-by Alejandro Colomar <[email protected]>Cc Martin Sebor <[email protected]>Cc Dave Martin <[email protected]>---
v6:
- GCC has always exposed 'void *', as Martin Sebor noted. It's Clang (and maybe others) that (following GCC's docs) exposed 'char *'.
Thanks, Alex. Patch applied.
Cheers,
Michael
Quoted 39 lines
man2/cacheflush.2 | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)man2/cacheflush.2 +24
-0@@ -86,6 +86,30 @@ On Linux, this call first appeared on the MIPS architecture, but nowadays, Linux provides a .BR cacheflush () system call on some other architectures, but with different arguments. +.SH NOTES +Unless you need the finer grained control that this system call provides, +you probably want to use the GCC built-in function +.BR __builtin___clear_cache (), +which provides a portable interface +across platforms supported by GCC and compatible compilers: +.PP +.in +4n +.EX +.BI "void __builtin___clear_cache(void *" begin ", void *" end ); +.EE +.in +.PP +On platforms that don't require instruction cache flushes, +.BR __builtin___clear_cache () +has no effect. +.PP +.IR Note : +On some GCC-compatible compilers, +the prototype for this built-in function uses +.I char * +instead of +.I void * +for the parameters. .SH BUGS Linux kernels older than version 2.6.11 ignore the .I addr
Signature · 8 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/ _______________________________________________ linux-snps-arc mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-snps-arc