How can I add a static assert to check if a variable is static?

I have a macro which works well o开发者_JS百科nly on static local variables (since it uses inline assembly notation to extract data about the variable). I need a way to enforce that the input to the macro is indeed a static local variable:

correct:

func f()
{
    static int x;
    my_macro(x);
}

not correct:

func f()
{
    int x;
    my_macro(x);
}

I work with GCC for C (no C++).

---

You can use following trick:

#define ASSERT_LOCAL_STATIC(v) static void *p_ ## v = &v

void fn()
{
    int nonstatic_var = 0;
    static int static_var = 0;

    ASSERT_LOCAL_STATIC(static_var);
    ASSERT_LOCAL_STATIC(nonstatic_var);
}

GCC issues an error "initializer element is not constant" for non-static variables.

---

You might be able to tell static and local variables apart by using their addresses:

• Static variables are stored in either the .BSS or .DATA sections

• Local variables are stored in the stack

For example the output of the following program on my system

#include <stdio.h>

void f0() {
    int x = 0;
    printf("%p\n", &x);
}

void f1() {
    static int x = 0;
    printf("%p\n", &x);
}

int main() {
        f0();
        f1();

        return 0;
}

is this:

0x7fff1dc718dc
0x600900

Where each section and the stack are placed depends on the ABI of your platform, but you could use the address of a block-local variable to form a condition:

#include <stdio.h>

#define check(var) { \
        int ___ = 0; \
        printf("%s (%p): %s\n", #var, &var, (&var > &___)?"local":"static"); \
}

void f0() {
    int x = 0;
    check(x);
}

void f1() {
    static int y = 0;
    check(y);
}

int main() {
        f0();
        f1();

        return 0;
}

This outputs:

x (0x7fff4b965afc): local
y (0x600978): static

Warning: I would not advise using this "trick". That's all it is: a trick, one that will break in the most unopportune of circumstances. Just document your macro properly and let the people who use it handle the aftermath of its misuse.

---

Simply do it in the way most C libraries use: Tell users that your macro works for static variables and the behavior for anything else may be undefined/unexpected.

Just like you can also pass NULL pointers to strdup() etc. which will result in nothing but a segfault there's not a big issue with not enforcing stuff.

---

I think you cannot distinguish these cases in ISO C. But since you already mentioned that you use GCC there may be some helpful built-in pseudo functions. Their names all start with __builtin_, so you should read through that list in the GCC documentation.

http://www.google.com/search?q=gcc+builtin

Well, I just read through the whole built-ins section, and I didn't find anything. So I think it is really not possible.

What are you trying to do anyway with the macro, just out of curiosity?