Hi I read https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html but was left wondering: is there a way to annotate a function to indicate that a return value is likely (or unlikely)?
For example, let's say we have this function: // Return OK (=0) in case of success (frequent case) // or an error code != 0 in case of failure (rare case). int do_something(); If it's unlikely to fail, I wish I could declare the function like this (pseudo-code!): int do_something() __likely_return(OK); So wherever it's used, the optimizer can optimize branch prediction and the instruction cache. In other words, lines like this: if (do_something() == OK) ... would implicitly be similar to: // LIKELY defined as __builtin_expect((x), 1). if (LIKELY(do_something() == OK)) The advantage of being able to annotate the declaration, is that we only need to annotate once in the header, and all uses of the function can benefit from the optimization without polluting/modifying all code where the function is called. Another example: a function that would be unlikely to return NULL could be declared as: void *foo() __unlikely_returns(NULL); This last example would be a bit similar to the __attribute__((malloc)) since I read about it in the doc: > In addition, the GCC predicts that a function with > the attribute returns non-null in most cases. Of course __attribute__((malloc)) gives other guarantees (return value cannot alias any other pointer) so it's not equivalent. Would attribute __likely_return() and __unlikely_return() make sense? Is there already a way to achieve this which I missed in the doc? Regards Dominique
