Skip to contentSkip to conversation

cacheflush.2

PATCH Superseded Heinrich Schuchardt 5 participants 22 messages Dec 9, 2020 – Dec 20, 2020

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

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

#1 lore raw

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
#2 lore raw
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

#3 lore raw

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
#4 lore raw

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#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; https://www.kernel.org/doc/man-pages/
http://www.alejandro-colomar.es
#5 lore raw
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#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

#6 lore raw

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_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 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#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 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
#7 lore raw

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_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 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#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 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/
#8 lore raw

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:

https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=gcc/builtins.def;h=fa8b0641ab13b36f983c591a7020f6b432e5fb3d;hb=refs/heads/releases/gcc-10#l837

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_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 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#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 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

#9 lore raw

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_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:

https://gcc.gnu.org/git/?p=gcc.git;a=blob;f=gcc/builtins.def;h=fa8b0641ab13b36f983c591a7020f6b432e5fb3d;hb=refs/heads/releases/gcc-10#l837

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_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 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#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 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'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/
#10 lore raw
In reply to Alejandro Colomar (man-pages)
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

#11 lore raw
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

#12 lore raw

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
#13 lore raw

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/
#14 lore raw

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
#15 lore raw

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
#16 lore raw

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
#17 lore raw

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
index aba625721..7a2eed506 100644
@@ -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
author Reviewed-by on v5 1/1
#18 lore raw

Re: [PATCH v5] cacheflush.2: Document __builtin___clear_cache() as a more portable alternative

Quoted 2 lines · Alejandro Colomar
Quoted 30 lines
---
  man2/cacheflush.2 | 24 ++++++++++++++++++++++++
  1 file changed, 24 insertions(+)
man2/cacheflush.2 +17 -0
index aba625721..7a2eed506 100644
@@ -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

#19 lore raw

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
index aba625721..7a2eed506 100644
@@ -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
#20 lore raw

Ping: [PATCH v6] cacheflush.2: Document __builtin___clear_cache() as a more portable alternative

Ping

Quoted 50 lines · Alejandro Colomar

---

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
index aba625721..7a2eed506 100644
@@ -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
#21 lore raw

Re: [PATCH v6] cacheflush.2: Document __builtin___clear_cache() as a more portable alternative

In reply to Alejandro Colomar
Quoted 10 lines · Alejandro Colomar

---

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
index aba625721..7a2eed506 100644
@@ -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