Fix build for mingw.

[abidh]

Summary

I was building lldb using cross mingw-w64 toolchain on Linux and observed some issues. This is first patch in the series to fix that build. It mostly corrects the case of include files and adjusts some #ifdefs from _MSC_VER to _WIN32 and vice versa. I built lldb on windows with VS after applying this patch to make sure it does not break the build there.

[labath]

I'll leave Zachary to approve, but it seems reasonable.

BTW, I am curious, are you planning on building python with mingw as well? If you are, I'd be interested in knowing how that works out.

cmake/modules/LLDBConfig.cmake

246

Could you check if it's enough to pass -DFOO regardless of the platform. This is the only usage of the /D version in the llvm codebase, which leads me to believe that msvc will accept the -D version as well (or cmake will somehow convert in for him.

source/Core/Mangled.cpp

12

Should we use LLVM_ON_WIN32 here? That seems to be the llvm preffered solution...

[zturner]

cmake/modules/LLDBConfig.cmake

246

I think the -D syntax works on both, so I would change this back to the original condition, and just change the / to a -

For example, right above this line you can see things like -wd4150, and right below this line you can see things like -D_LARGEFILE_SOURCE

[abidh]

BTW, I am curious, are you planning on building python with mingw as well? If you are, I'd be interested in knowing how that works out.

I would like to do it but have not done it yet. I will keep you posted.

cmake/modules/LLDBConfig.cmake

246

OK. I will change it accordingly.

source/Core/Mangled.cpp

12

Do you mean use LLVM_ON_WIN32 everywhere instead of _WIN32 or just here?

[labath]

Yeah, I meant using it everywhere as a generic "am I on windows, regardless of the compiler" check. (Assuming Zach is fine with that)

[abidh]

In D27759#622332, @labath wrote:

Yeah, I meant using it everywhere as a generic "am I on windows, regardless of the compiler" check. (Assuming Zach is fine with that)

OK. If Zachary is fine with that then I can do that in a separate commit.

@zturner
Do you have any other comment on this patch ?

[abidh]

Replaced /D with -D as per comments.

[abidh]

Accepted in email.

cmake/LLDBDependencies.cmake

set( LLDB_USED_LIBS
   lldbPluginExpressionParserClang
   lldbPluginExpressionParserGo
   )
 
 # Windows-only libraries
 if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
   list(APPEND LLDB_USED_LIBS
     lldbPluginProcessWindowsCommon
-    Ws2_32
-    Rpcrt4
+    ws2_32
+    rpcrt4
     )
 endif ()
 
 # Linux-only libraries
 if ( CMAKE_SYSTEM_NAME MATCHES "Linux" )
   list(APPEND LLDB_USED_LIBS
     lldbPluginProcessLinux
     lldbPluginProcessPOSIX

cmake/modules/AddLLDB.cmake

else ()
     # PARAM_STATIC or library type unspecified. BUILD_SHARED_LIBS
     # does not control the kind of libraries created for LLDB,
     # only whether or not they link to shared/static LLVM/Clang
     # libraries.
     set(libkind STATIC)
   endif()
 
   #PIC not needed on Win
-  if (NOT MSVC)
+  if (NOT WIN32)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
   endif()
 
   if (PARAM_OBJECT)
     add_library(${name} ${libkind} ${srcs})
   else()
     if (PARAM_SHARED)
       if (LLDB_LINKER_SUPPORTS_GROUPS)

cmake/modules/LLDBConfig.cmake

add_definitions(
     -wd4150 # Suppress 'warning C4150: deletion of pointer to incomplete type'
     -wd4251 # Suppress 'warning C4251: T must have dll-interface to be used by clients of class U.'
     -wd4521 # Suppress 'warning C4521: 'type' : multiple copy constructors specified'
     -wd4530 # Suppress 'warning C4530: C++ exception handler used, but unwind semantics are not enabled.'
   )
 endif()
 
 # Use the Unicode (UTF-16) APIs by default on Win32
-if (CMAKE_SYSTEM_NAME MATCHES "Windows")
-  add_definitions( /D _UNICODE /D UNICODE )
+if (MSVC)
+    add_definitions( /D _UNICODE /D UNICODE )
+elseif (MINGW)
+    add_definitions( -D_UNICODE -DUNICODE )
 endif()
 
 set(LLDB_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(LLDB_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 # If building on a 32-bit system, make sure off_t can store offsets > 2GB
 if( CMAKE_SIZEOF_VOID_P EQUAL 4 )
   add_definitions( -D_LARGEFILE_SOURCE )

include/lldb/Host/windows/windows.h

 //===-- lldb-windows.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_lldb_windows_h_
 #define LLDB_lldb_windows_h_
 
 #define NTDDI_VERSION NTDDI_VISTA
+#undef _WIN32_WINNT // undef a previous definition to avoid warning
 #define _WIN32_WINNT _WIN32_WINNT_VISTA
 #define WIN32_LEAN_AND_MEAN
 #define NOGDI
+#undef NOMINMAX // undef a previous definition to avoid warning
 #define NOMINMAX
 #include <windows.h>
 #undef GetUserName
 #undef LoadImage
 #undef CreateProcess
 #undef far
 #undef near
 #undef FAR
 #undef NEAR
 #define FAR
 #define NEAR
 
 #endif // LLDB_lldb_windows_h_

source/API/SystemInitializerFull.cpp

 #include "Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h"
 #endif
 #include "Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h"
 
 #if defined(__FreeBSD__)
 #include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
 #endif
 
-#if defined(_MSC_VER)
+#if defined(_WIN32)
 #include "Plugins/Process/Windows/Common/ProcessWindows.h"
 #include "lldb/Host/windows/windows.h"
 #endif
 
 #include "llvm/Support/TargetSelect.h"
 
 #include <string>
 
#endif
 
   CPlusPlusLanguage::Initialize();
   GoLanguage::Initialize();
   JavaLanguage::Initialize();
   ObjCLanguage::Initialize();
   ObjCPlusPlusLanguage::Initialize();
   OCamlLanguage::Initialize();
 
-#if defined(_MSC_VER)
+#if defined(_WIN32)
   ProcessWindows::Initialize();
 #endif
 #if defined(__FreeBSD__)
   ProcessFreeBSD::Initialize();
 #endif
 #if defined(__APPLE__)
   SymbolVendorMacOSX::Initialize();
   ProcessKDP::Initialize();

source/Core/Mangled.cpp

 //===-- Mangled.cpp ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // FreeBSD9-STABLE requires this to know about size_t in cxxabi.h
 #include <cstddef>
-#if defined(_MSC_VER)
+#if defined(_WIN32)
 #include "lldb/Host/windows/windows.h"
-#include <Dbghelp.h>
+#include <dbghelp.h>
 #pragma comment(lib, "dbghelp.lib")
 #endif
 
 #ifdef LLDB_USE_BUILTIN_DEMANGLER
 // Provide a fast-path demangler implemented in FastDemangle.cpp until it can
 // replace the existing C++ demangler with a complete implementation
 #include "llvm/Demangle/Demangle.h"
 #include "lldb/Core/FastDemangle.h"

source/Host/common/File.cpp

if (permissions & lldb::eFilePermissionsWorldRead)
       mode |= S_IROTH;
     if (permissions & lldb::eFilePermissionsWorldWrite)
       mode |= S_IWOTH;
     if (permissions & lldb::eFilePermissionsWorldExecute)
       mode |= S_IXOTH;
   }
 
   do {
-#ifdef _WIN32
+#ifdef _MSC_VER
     std::wstring wpath;
     if (!llvm::ConvertUTF8toWide(path, wpath)) {
       m_descriptor = -1;
       error.SetErrorString("Error converting path to UTF-16");
       return error;
     }
     ::_wsopen_s(&m_descriptor, wpath.c_str(), oflag, _SH_DENYNO, mode);
 #else

source/Host/windows/Host.cpp

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 
 #include "llvm/Support/ConvertUTF.h"
 
 // Windows includes
-#include <TlHelp32.h>
+#include <tlhelp32.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
 namespace {
 bool GetTripleForProcess(const FileSpec &executable, llvm::Triple &triple) {
   // Open the PE File as a binary file, and parse just enough information to
   // determine the

source/Host/windows/HostProcessWindows.cpp

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/ThreadLauncher.h"
 #include "lldb/Host/windows/windows.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ConvertUTF.h"
 
-#include <Psapi.h>
+#include <psapi.h>
 
 using namespace lldb_private;
 
 namespace {
 struct MonitorInfo {
   Host::MonitorChildProcessCallback callback;
   HANDLE process_handle;
 };

source/Host/windows/ProcessRunLock.cpp

 //===-- ProcessRunLock.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/ProcessRunLock.h"
 #include "lldb/Host/windows/windows.h"
 
-namespace {
-#if defined(__MINGW32__)
-// Taken from WinNT.h
-typedef struct _RTL_SRWLOCK { PVOID Ptr; } RTL_SRWLOCK, *PRTL_SRWLOCK;
-
-// Taken from WinBase.h
-typedef RTL_SRWLOCK SRWLOCK, *PSRWLOCK;
-#endif
-}
-
 static PSRWLOCK GetLock(lldb::rwlock_t lock) {
   return static_cast<PSRWLOCK>(lock);
 }
 
 static bool ReadLock(lldb::rwlock_t rwlock) {
   ::AcquireSRWLockShared(GetLock(rwlock));
   return true;
 }

source/Plugins/ObjectFile/PECOFF/WindowsMiniDump.cpp

 // collisions with WinAPI preprocessor macros.
 
 #include "WindowsMiniDump.h"
 #include "lldb/Host/FileSpec.h"
 #include "llvm/Support/ConvertUTF.h"
 
 #ifdef _WIN32
 #include "lldb/Host/windows/windows.h"
-#include <DbgHelp.h> // for MiniDumpWriteDump
+#include <dbghelp.h> // for MiniDumpWriteDump
 #endif
 
 namespace lldb_private {
 
 bool SaveMiniDump(const lldb::ProcessSP &process_sp,
                   const lldb_private::FileSpec &outfile,
                   lldb_private::Error &error) {
   if (!process_sp)

source/Plugins/Process/Windows/Common/ExceptionRecord.h

 //===-- ExceptionRecord.h ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Plugins_Process_Windows_ExceptionRecord_H_
 #define liblldb_Plugins_Process_Windows_ExceptionRecord_H_
 
 #include "lldb/Host/windows/windows.h"
 #include "lldb/lldb-forward.h"
-#include <DbgHelp.h>
+#include <dbghelp.h>
 
 #include <memory>
 #include <vector>
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // ExceptionRecord

source/Target/ProcessLaunchInfo.cpp

if (m_flags.Test(eLaunchFlagDisableSTDIO)) {
           (!in_file_spec || !out_file_spec || !err_file_spec)) {
         if (log)
           log->Printf("ProcessLaunchInfo::%s default_to_use_pty is set, and at "
                       "least one stdin/stderr/stdout is unset, so generating a "
                       "pty to use for it",
                       __FUNCTION__);
 
         int open_flags = O_RDWR | O_NOCTTY;
-#if !defined(_MSC_VER)
+#if !defined(_WIN32)
         // We really shouldn't be specifying platform specific flags
         // that are intended for a system call in generic code.  But
         // this will have to do for now.
         open_flags |= O_CLOEXEC;
 #endif
         if (m_pty->OpenFirstAvailableMaster(open_flags, nullptr, 0)) {
           const FileSpec slave_file_spec{m_pty->GetSlaveName(nullptr, 0),
                                          false};

tools/driver/Driver.cpp

if (g_driver)
     g_driver->GetDebugger().RestoreInputTerminalState();
 
   signal(signo, SIG_DFL);
   kill(getpid(), signo);
   signal(signo, sigcont_handler);
 }
 
 int
-#ifdef WIN32
+#ifdef _MSC_VER
 wmain(int argc, wchar_t const *wargv[])
 #else
 main(int argc, char const *argv[])
 #endif
 {
-#ifdef _WIN32
+#ifdef _MSC_VER
   // Convert wide arguments to UTF-8
   std::vector<std::string> argvStrings(argc);
   std::vector<const char *> argvPointers(argc);
   for (int i = 0; i != argc; ++i) {
     llvm::convertWideToUTF8(wargv[i], argvStrings[i]);
     argvPointers[i] = argvStrings[i].c_str();
   }
   const char **argv = argvPointers.data();

tools/lldb-mi/MICmnStreamStdin.cpp

 //===-- MICmnStreamStdin.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Third Party Headers
 #ifdef _MSC_VER
-#include <Windows.h>
+#include <windows.h>
 #endif
 #include <string.h> // For std::strerror()
 
 // In-house headers:
 #include "MICmnLog.h"
 #include "MICmnResources.h"
 #include "MICmnStreamStdin.h"
 #include "MICmnStreamStdout.h"

tools/lldb-mi/MIUtilDebug.cpp

 //===-- MIUtilDebug.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Third party headers:
 #ifdef _WIN32
-#include <Windows.h>
+#include <windows.h>
 #endif
 
 // In-house headers:
 #include "MICmnLog.h"
 #include "MIDriver.h"
 #include "MIUtilDebug.h"
 
 //++