[Support] Fix some Wundef warnings

[svenvh]

Summary

For the _WIN32 macro, it is the definedness that matters rather than
the value. Most uses already rely on the definedness; this commit
fixes the few remaining uses that relied on the value.

llvm/trunk/lib/Support/COM.cpp

 
 #include "llvm/Support/COM.h"
 
 #include "llvm/Config/llvm-config.h"
 
 // Include the platform-specific parts of this class.
 #ifdef LLVM_ON_UNIX
 #include "Unix/COM.inc"
-#elif _WIN32
+#elif defined(_WIN32)
 #include "Windows/COM.inc"
 #endif

llvm/trunk/lib/Support/CodeGenCoverage.cpp

 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 #if LLVM_ON_UNIX
 #include <unistd.h>
-#elif _WIN32
+#elif defined(_WIN32)
 #include <windows.h>
 #endif
 
 using namespace llvm;
 
 static sys::SmartMutex<true> OutputMutex;
 
 CodeGenCoverage::CodeGenCoverage() {}
if (!CoveragePrefix.empty() && !RuleCoverage.empty()) {
     sys::SmartScopedLock<true> Lock(OutputMutex);
 
     // We can handle locking within a process easily enough but we don't want to
     // manage it between multiple processes. Use the process ID to ensure no
     // more than one process is ever writing to the same file at the same time.
     std::string Pid =
 #if LLVM_ON_UNIX
         llvm::to_string(::getpid());
-#elif _WIN32
+#elif defined(_WIN32)
         llvm::to_string(::GetCurrentProcessId());
 #else
         "";
 #endif
 
     std::string CoverageFilename = (CoveragePrefix + Pid).str();
 
     std::error_code EC;

llvm/trunk/lib/Support/Locale.cpp

 #include "llvm/Support/Locale.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Unicode.h"
 
 namespace llvm {
 namespace sys {
 namespace locale {
 
 int columnWidth(StringRef Text) {
-#if _WIN32
+#ifdef _WIN32
   return Text.size();
 #else
   return llvm::sys::unicode::columnWidthUTF8(Text);
 #endif
 }
 
 bool isPrint(int UCS) {
-#if _WIN32
+#ifdef _WIN32
   // Restrict characters that we'll try to print to the lower part of ASCII
   // except for the control characters (0x20 - 0x7E). In general one can not
   // reliably output code points U+0080 and higher using narrow character C/C++
   // output functions in Windows, because the meaning of the upper 128 codes is
   // determined by the active code page in the console.
   return ' ' <= UCS && UCS <= '~';
 #else
   return llvm::sys::unicode::isPrintable(UCS);
 #endif
 }
 
 } // namespace locale
 } // namespace sys
 } // namespace llvm

llvm/trunk/lib/Support/LockFileManager.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <cerrno>
 #include <ctime>
 #include <memory>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <system_error>
 #include <tuple>
-#if _WIN32
+#ifdef _WIN32
 #include <windows.h>
 #endif
 #if LLVM_ON_UNIX
 #include <unistd.h>
 #endif
 
 #if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && (__MAC_OS_X_VERSION_MIN_REQUIRED > 1050)
 #define USE_OSX_GETHOSTUUID 1
LockFileManager::~LockFileManager() {
   // matches a sys::RemoveFileOnSignal() in LockFileManager().
   sys::DontRemoveFileOnSignal(UniqueLockFileName);
 }
 
 LockFileManager::WaitForUnlockResult LockFileManager::waitForUnlock() {
   if (getState() != LFS_Shared)
     return Res_Success;
 
-#if _WIN32
+#ifdef _WIN32
   unsigned long Interval = 1;
 #else
   struct timespec Interval;
   Interval.tv_sec = 0;
   Interval.tv_nsec = 1000000;
 #endif
   // Don't wait more than 40s per iteration. Total timeout for the file
   // to appear is ~1.5 minutes.
   const unsigned MaxSeconds = 40;
   do {
     // Sleep for the designated interval, to allow the owning process time to
     // finish up and remove the lock file.
     // FIXME: Should we hook in to system APIs to get a notification when the
     // lock file is deleted?
-#if _WIN32
+#ifdef _WIN32
     Sleep(Interval);
 #else
     nanosleep(&Interval, nullptr);
 #endif
 
     if (sys::fs::access(LockFileName.c_str(), sys::fs::AccessMode::Exist) ==
         errc::no_such_file_or_directory) {
       // If the original file wasn't created, somone thought the lock was dead.
       if (!sys::fs::exists(FileName))
         return Res_OwnerDied;
       return Res_Success;
     }
 
     // If the process owning the lock died without cleaning up, just bail out.
     if (!processStillExecuting((*Owner).first, (*Owner).second))
       return Res_OwnerDied;
 
     // Exponentially increase the time we wait for the lock to be removed.
-#if _WIN32
+#ifdef _WIN32
     Interval *= 2;
 #else
     Interval.tv_sec *= 2;
     Interval.tv_nsec *= 2;
     if (Interval.tv_nsec >= 1000000000) {
       ++Interval.tv_sec;
       Interval.tv_nsec -= 1000000000;
     }
 #endif
   } while (
-#if _WIN32
+#ifdef _WIN32
            Interval < MaxSeconds * 1000
 #else
            Interval.tv_sec < (time_t)MaxSeconds
 #endif
            );
 
   // Give up.
   return Res_Timeout;
 }
 
 std::error_code LockFileManager::unsafeRemoveLockFile() {
   return sys::fs::remove(LockFileName);
 }