Function pointer to __attribute__((const)) function?

Question

How (in GCC/"GNU C") do you declare a function pointer which points to an __attribute__((const)) function? The idea being that I want the compiler to avoid generating multiple calls to the function called through the function pointer when it can cache the return value from a previous call.

Answer 1

typedef void (*t_const_function)(void) __attribute__((const));

static __attribute__((const)) void A(void) {
}

static void B(void) {
}

int main(int argc, const char* argv[]) {
    t_const_function a = A;

    // warning: initialization makes qualified
    // function pointer from unqualified:
    t_const_function b = B;

    return 0;
}

Or just:

__attribute__((const)) void(*a)(void) = A;

Answer 2

GCC 12.2.1 treats __attribute__((pure)) and __attribute__((const)) subtly differently. The former applies only to function declarations, never to types, while the latter actually can be applied both to function declarations and to pointer-to-function types (but not to function types!).

/* Function declarations */

int const_fn(int) __attribute__((const)); // OK
int pure_fn(int) __attribute__((pure)); // OK


/* Function type definitions */

typedef int const_fn0_t(int) __attribute__((const)); // warning: 'const' attribute ignored
typedef int pure_fn0_t(int) __attribute__((pure)); // warning: 'pure' attribute ignored

typedef int __attribute__((const)) const_fn1_t(int); // warning: 'const' attribute ignored
typedef int __attribute__((pure)) pure_fn1_t(int); // warning: 'pure' attribute ignored

typedef __attribute__((const)) int const_fn2_t(int); // warning: 'const' attribute ignored
typedef __attribute__((pure)) int pure_fn2_t(int); // warning: 'pure' attribute ignored

__attribute__((const)) typedef int const_fn3_t(int); // warning: 'const' attribute ignored
__attribute__((pure)) typedef int pure_fn3_t(int); // warning: 'pure' attribute ignored


/* Pointer-to-function type definitions */

typedef int (*const_fn0_ptr_t)(int) __attribute__((const)); // OK
typedef int (*pure_fn0_ptr_t)(int) __attribute__((pure)); // warning: 'pure' attribute ignored

typedef int (* __attribute__((const)) const_fn1_ptr_t)(int); // OK
typedef int (* __attribute__((pure)) pure_fn1_ptr_t)(int); // warning: 'pure' attribute ignored

typedef int __attribute__((const)) (*const_fn2_ptr_t)(int); // OK
typedef int __attribute__((pure)) (*pure_fn2_ptr_t)(int); // warning: 'pure' attribute ignored

typedef __attribute__((const)) int (*const_fn3_ptr_t)(int); // OK
typedef __attribute__((pure)) int (*pure_fn3_ptr_t)(int); // warning: 'pure' attribute ignored

__attribute__((const)) typedef int (*const_fn4_ptr_t)(int); // OK
__attribute__((pure)) typedef int (*pure_fn4_ptr_t)(int); // warning: 'pure' attribute ignored


void demo(const_fn0_t *pcf0,
          const_fn1_t *pcf1,
          const_fn2_t *pcf2,
          const_fn3_t *pcf3,
          pure_fn0_t *ppf0,
          pure_fn1_t *ppf1,
          pure_fn2_t *ppf2,
          pure_fn3_t *ppf3,
          const_fn0_ptr_t cfp0,
          const_fn1_ptr_t cfp1,
          const_fn2_ptr_t cfp2,
          const_fn3_ptr_t cfp3,
          const_fn4_ptr_t cfp4,
          pure_fn0_ptr_t pfp0,
          pure_fn1_ptr_t pfp1,
          pure_fn2_ptr_t pfp2,
          pure_fn3_ptr_t pfp3,
          pure_fn4_ptr_t pfp4)
{
    /* calling functions directly */
    const_fn(0); // warning: statement with no effect
    pure_fn(0); // warning: statement with no effect

    /* calling through pointers to function types */
    pcf0(0); // no warning
    pcf1(0); // no warning
    pcf2(0); // no warning
    pcf3(0); // no warning
    ppf0(0); // no warning
    ppf1(0); // no warning
    ppf2(0); // no warning
    ppf3(0); // no warning

    /* calling through pointer-to-function types */
    cfp0(0); // warning: statement with no effect
    cfp1(0); // warning: statement with no effect
    cfp2(0); // warning: statement with no effect
    cfp3(0); // warning: statement with no effect
    cfp4(0); // warning: statement with no effect
    pfp0(0); // no warning
    pfp1(0); // no warning
    pfp2(0); // no warning
    pfp3(0); // no warning
    pfp4(0); // no warning
}

You actually can attach the attribute to multiple levels of pointer indirection:

typedef int (*const_fn_ptr_t)(int) __attribute__((const));

int demo1(const_fn_ptr_t (*pcf)(void) __attribute__((const))) {
    pcf(); // warning: statement with no effect
    pcf()(0); // warning: statement with no effect

    const_fn_ptr_t cfp = pcf(); // no warning
    cfp(0); // warning: statement with no effect
    return cfp(0); // no warning
}

The demo1 function above takes one argument, which is of type “pointer to a function that takes no arguments, is constant, and returns a pointer to a function that takes an integer argument, is constant, and returns an integer.”

All of the preceding leads up to an answer to OP's question. You can declare a pointer to a constant function (but cannot declare a pointer a pure function) thusly:

int (*pf)(void *) __attribute__((const));

In a function parameter list, it might look like:

void sort(void *array[],
          size_t array_size,
          int (*compare)(const void *, const void *) __attribute__((const)))
{
    compare(array[0], array[1]); // warning: statement with no effect
}

Unfortunately, I have found no way to attach __attribute__((const)) to a pointer-to-function type outside of a declaration. In particular, it does not work in a cast:

void demo2(int (*pf)(int)) {
    ((int (* __attribute((const)))(int)) pf)(0); // warning: 'const' attribute does not apply to types
}

However, you can cast a pointer-to-function to a typedef'd pointer-to-constant-function type:

void demo3(int (*pf)(int)) {
    pf(0); // no warning
    typedef int (*cfp_t)(int) __attribute__((const));
    ((cfp_t) pf)(0); // warning: statement with no effect
}

If any GCC developer is reading this, please fix __attribute__((pure)) so it has the same applicability as __attribute__((const)).

Answer 3

Although this is not quite the answer to your question, you probably want to know this:

You can't in the general case expect the compiler to perform the optimization you expect here. The compiler cannot in the general case do the alias analysis necessary to know that multiple uses of a function pointer correspond to the same function.

A function call in between two invocations of the function through the pointer could, in the general case, alter the pointer contents, thus causing the invoked function to be different in the second call.

Because of the nature of C, doing proper alias analysis is often intractable, and this sort of optimization is thus not likely to happen.