How to enforce the usage of return values in C

Question

I'm searching for a compiler flag for gcc and if possible for clang and the Microsoft compilers as well, that triggers a warning (error with -Werror) if a non-void function is called without using the return value like this:

int test() {
    return 4;
}

int main(void) {
    test(); //should trigger a warning
    int number = test(); //shouldn't trigger the warning
    return 0;
}

If there is no such compiler flag, maybe some way to tell the clang static analyzer to complain about it.

EDIT: To clarify my original question: I actually meant using the return value, not only assigning it.

Answer 1

I never used it myself (do you really need it?), you can try

• defining the function with warn_unused_result attribute
• enabling -Wunused-result flag with gcc.

This will tell you about any unused value from the function return.

---

In case, any doubts, SEE IT LIVE or SEE IT LIVE AGAIN ^{Thanks to M.M for the link in the comment}

Or:

#include <stdio.h>

extern int func1(void) __attribute__((warn_unused_result));
extern int func2(void);

int main(void)
{
    func1();
    int rc1 = func1();
    int rc2 = func1();
    func2();
    printf("%d\n", rc1);
    return 0;
}

Compilation (GCC 5.1.0 on Mac OS X 10.10.5):

$ gcc -O3 -g -std=c11 -Wall -Wextra -Werror -c warn.c
warn.c: In function ‘main’:
warn.c:10:9: error: unused variable ‘rc2’ [-Werror=unused-variable]
     int rc2 = func1();
         ^
warn.c:8:5: error: ignoring return value of ‘func1’, declared with attribute warn_unused_result [-Werror=unused-result]
     func1();
     ^
cc1: all warnings being treated as errors
$

Answer 2

Some static code analyzers like splint can check for these kind of things:

$ splint check.c
Splint 3.1.2 --- 03 May 2009

check.c: (in function main)
check.c:6:5: Return value (type int) ignored: test()
  Result returned by function call is not used. If this is intended, can cast
  result to (void) to eliminate message. (Use -retvalint to inhibit warning)

Unlike @Sourav's answer, this does not require a specific __attribute__ annotation on the target function, but on the other hand possibly emits many warnings. Its usually possible to suppress the warnings for specific functions or function calls by using annotations (like /*@alt void@*/).