I've met a simillar problem and found another nice trick to implement your TEST_BXI_MACRO_EXISTS with no string.h and extra function calls:

#define STRINGIZE_I(x) #x
#define TEST_BXI_MACRO_EXISTS(name) (#name [0] != STRINGIZE_I(name) [0])

This trick uses the same assumption that stringized value of defined macro does not match stringized name of that macro. But for my case I only needed to check if macro is defined as a numeric constant, string literal or empty value. No function-like macros and other stuff.

This is how it works:

#define MACRO "Content"
TEST_BXI_MACRO_EXISTS(MACRO)
// translates to ("MACRO"[0] != "\"Content\""[0])
// first letter of a valid macro name can never be equal to '"'

#define MACRO 3.14
TEST_BXI_MACRO_EXISTS(MACRO)
// translates to ("MACRO"[0] != "3.14"[0])
// first letter of a valid macro name can never be equal to a digit

#define MACRO
TEST_BXI_MACRO_EXISTS(MACRO)
// translates to ("MACRO"[0] != ""[0])
// first letter of a valid macro name can never be equal to a '\0'

This approach can also be easily used to test whether macro defines a numeric constant, string literal or empty value like your approach does by checking the value of STRINGIZE_I(name) [0].

So far I have no idea how to test function-like macros this way, but I thought sharing this with others could be useful anyway.

But, as this is Q&A-style article, I've found the solution.

The final result looks as follows:

TEST_BXI_MACRO_STRING(BXI_OS);
TEST_BXI_MACRO_STRING(BXI_ARCH);
TEST_BXI_MACRO_I32   (BXI_BITS);
TEST_BXI_MACRO_EXISTS_WEAK(BXI_ARCH_X32); // _WEAK as we don't need to fail
TEST_BXI_MACRO_EXISTS_WEAK(BXI_ARCH_X64);

The result:

Let us see every one of them closely

TEST_BXI_MACRO_STRING

This one is pretty simple:

#define TEST_BXI_MACRO_STRING(name)              \
do                                               \
{                                                \
    print_macro_name(#name);                     \
    if (!TEST_BXI_MACRO_DEFINED(#name, name(1))) \
        print_macro_undefined_exit();            \
    if (strlen(name "") == 0)                    \
        print_macro_undefined_exit();            \
    print_macro_value_string(name "");           \
}                                                \
while (0)

We just using the idea that C allows const strings auto-concatenation. So when the macro exists we will receive

 #define MACRO "Content"
 "Content" "" = "Content"

and when it doesn't

 "" = ""

Then we look at the length of the resulting string, and when it's 0 - bingo, macro is not defined. This will NOT work for "" macro, but this special case could be checked with TEST_BXI_MACRO_EXISTS

TEST_BXI_MACRO_I32

#define TEST_BXI_MACRO_I32(name)                 \
do                                               \
{                                                \
    print_macro_name(#name);                     \
    if (!TEST_BXI_MACRO_DEFINED(#name, name(1))) \
        print_macro_undefined_exit();            \
    if ((5 * name + 1) == 5)                     \
         print_macro_undefined_exit();           \
    print_macro_value_signed(name + 0);          \
}                                                \
while (0)

NOTE: you can similarly create ...MACRO_U32 version just by replacing the printer formatter.

Here we use the fact that '+' operator could be unary AND binary. Let us simulate three cases:

#define MACRO (10)

In this case the complete formula will look as follows:

5 * 10 + 1 => 50 + 1 => 51

#define MACRO (0)

In this case the multiplication fades out:

5 * 0 + 1 => 0 + 1 => 1

In some cases you can use this for additional check if the defined macro is 0 (like for preprocessing options and stuff)

#define MACRO

This case shows some math magic:

5 *    + 1 => 5 * (+1) => 5 * 1 => 5

As +1 is interpreted as simple 1 we receive 5.

TEST_BXI_MACRO_EXISTS

#define TEST_BXI_MACRO_DEFINED_I(strstr, fnc) (strcmp(#fnc, strstr "(1)"))
#define TEST_BXI_MACRO_DEFINED(str, fnc) TEST_BXI_MACRO_DEFINED_I(str, fnc)

#define TEST_BXI_MACRO_EXISTS(name)              \
do                                               \
{                                                \
    print_macro_name(#name);                     \
    if (!TEST_BXI_MACRO_DEFINED(#name, name(1))) \
        print_macro_undefined_exit();            \
    else                                         \
        print_macro_defined();                   \
}                                                \
while (0)

This implementation uses the fact that the string value of macro should not expand same as its name (as #define A A is useles)

Additional functions

For those who want the printing functions, here they are:

void print_macro_name(const char * name)
{
    printf("        checking: %-20s: ", name);
}

void print_macro_undefined_exit(void)
{
    printf("\033[1;31mUNDEFINED\033[0m\n");
    exit(1);
}

void print_macro_defined(void)
{
    printf("\033[1;33mDEFINED\033[0m\n");
}

void print_macro_undefined(void)
{
    printf("\033[1;32mUNDEFINED\033[0m\n");
}

void print_macro_value_string(const char * value)
{
    printf("\"%s\"\n", value);
}

void print_macro_value_signed(i32 value)
{
    printf("%d\n", value);
}

void print_macro_value_unsigned(u32 value)
{
    printf("%u\n", value);
}