[sanitizer] Ensure macro parameters are expanded before stringifying.

[mpividori]

Summary

I update the macro STRINGIFY() so use an auxiliary macro STRINGIFY_(), so we ensure the parameters are expanded before stringifying.
It is needed for future uses of STRINGIFY().

compiler-rt/trunk/lib/sanitizer_common/sanitizer_win_defs.h

 
 #if defined(_WIN64)
 #define WIN_SYM_PREFIX
 #else
 #define WIN_SYM_PREFIX "_"
 #endif
 
 // Intermediate macro to ensure the parameter is expanded before stringified.
-#define STRINGIFY(A) #A
+#define STRINGIFY_(A) #A
+#define STRINGIFY(A) STRINGIFY_(A)
 
 // ----------------- A workaround for the absence of weak symbols --------------
 // We don't have a direct equivalent of weak symbols when using MSVC, but we can
 // use the /alternatename directive to tell the linker to default a specific
 // symbol to a specific value.
 // Take into account that this is a pragma directive for the linker, so it will
 // be ignored by the compiler and the function will be marked as UNDEF in the
 // symbol table of the resulting object file. The linker won't find the default
 // implementation until it links with that object file.
 // So, suppose we provide a default implementation "fundef" for "fun", and this
 // is compiled into the object file "test.obj" including the pragma directive.
 // If we have some code with references to "fun" and we link that code with
 // "test.obj", it will work because the linker always link object files.
 // But, if "test.obj" is included in a static library, like "test.lib", then the
 // liker will only link to "test.obj" if necessary. If we only included the
 // definition of "fun", it won't link to "test.obj" (from test.lib) because
 // "fun" appears as UNDEF, so it doesn't resolve the symbol "fun", and will
 // result in a link error (the linker doesn't find the pragma directive).
 // So, a workaround is to force linkage with the modules that include weak
 // definitions, with the following macro: WIN_FORCE_LINK()
 
-#define WIN_WEAK_ALIAS_(Name, Default)                                         \
+#define WIN_WEAK_ALIAS(Name, Default)                                          \
   __pragma(comment(linker, "/alternatename:" WIN_SYM_PREFIX STRINGIFY(Name) "="\
                                              WIN_SYM_PREFIX STRINGIFY(Default)))
 
-#define WIN_WEAK_ALIAS(Name, Default)                                          \
-  WIN_WEAK_ALIAS_(Name, Default)
-
 #define WIN_FORCE_LINK(Name)                                                   \
   __pragma(comment(linker, "/include:" WIN_SYM_PREFIX STRINGIFY(Name)))
 
 #define WIN_EXPORT(ExportedName, Name)                                         \
   __pragma(comment(linker, "/export:" WIN_SYM_PREFIX STRINGIFY(ExportedName)   \
                                   "=" WIN_SYM_PREFIX STRINGIFY(Name)))
 
 // We cannot define weak functions on Windows, but we can use WIN_WEAK_ALIAS()