Make LLDB -Werror clean under clang

[zturner]

Summary

Some of this is in Windows specific code, but some of it is not. In a few places I think I fixed real bugs in LLDB, but not sure how to really test this.

[labath]

Seems reasonable. For testing we'll yell at you if the buildbots break.

I take it we can now freely use the %z printf modifier.

[zturner]

Thankfully, yes. Technically it's not supported by MSVC 2013, which is still a supported LLVM compiler. But we said long ago that we require MSVC 2015 for running the test suite on Windows. And in any case, LLVM is bumping to MSVC 2015 within the next 2 weeks. So I'm going to go ahead and start using %z now.

[Eugene.Zelenko]

tools/lldb-mi/Platform.h

16

This is application header. Should be in quotes. Same below.

[zturner]

tools/lldb-mi/Platform.h

16

Thanks for pointing this out. Fixed locally

[amccarth]

lgtm

source/Host/common/UDPSocket.cpp

106

Yuck. Given that this is going to get reduced from UTF-16 to MBCS, it might be cleaner to leave the format string alone and call gai_strerrorA explicitly on Windows. I guess it would be just as ugly that way.

source/Utility/SelectHelper.cpp

122

I find this logic less clear than the original version, since it's not obvious that updateMaxFd uses an in-out parameter until you go look up to see what it does. It also seems weird to have an output parameter come before an input-only parameter.

Perhaps if updateMaxFd returned the value instead of updating the parameter, it would be more obvious:

max_fd = updateMaxFd(max_fd, fd);

include/lldb/Host/windows/HostProcessWindows.h

 class HostProcessWindows : public HostNativeProcessBase {
 public:
   HostProcessWindows();
   explicit HostProcessWindows(lldb::process_t process);
   ~HostProcessWindows();
 
   void SetOwnsHandle(bool owns);
 
-  virtual Error Terminate();
-  virtual Error GetMainModule(FileSpec &file_spec) const;
+  Error Terminate() override;
+  Error GetMainModule(FileSpec &file_spec) const override;
 
-  virtual lldb::pid_t GetProcessId() const;
-  virtual bool IsRunning() const;
+  lldb::pid_t GetProcessId() const override;
+  bool IsRunning() const override;
 
   HostThread StartMonitoring(const Host::MonitorChildProcessCallback &callback,
                              bool monitor_signals) override;
 
 private:
   static lldb::thread_result_t MonitorThread(void *thread_arg);
 
   void Close();
 
   bool m_owns_handle;
 };
 }
 
 #endif

include/lldb/Host/windows/PosixApi.h

 #include <inttypes.h>
 
 // open(), close(), creat(), etc.
 #include <io.h>
 
 typedef unsigned short mode_t;
 
 // pyconfig.h typedefs this.  We require python headers to be included before
-// any
-// LLDB headers, but there's no way to prevent python's pid_t definition from
-// leaking, so this is the best option.
-#ifndef Py_CONFIG_H
+// any LLDB headers, but there's no way to prevent python's pid_t definition
+// from leaking, so this is the best option.
+#ifndef NO_PID_T
 typedef uint32_t pid_t;
 #endif
 
 #define STDIN_FILENO 0
 #define STDOUT_FILENO 1
 #define STDERR_FILENO 2
 
 #define S_IFDIR _S_IFDIR
+
+#ifndef S_ISDIR
 #define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)
+#endif
 
 #endif // _MSC_VER
 
 // MSVC 2015 and higher have timespec.  Otherwise we need to define it
 // ourselves.
 #if !defined(_MSC_VER) || _MSC_VER < 1900
 struct timespec {
   time_t tv_sec;

include/lldb/Utility/SelectHelper.h

public:
   // absolute timeout as this class manages to set the relative timeout
   // correctly.
   void SetTimeout(const std::chrono::microseconds &timeout);
 
   // Call the FDSet*() functions before calling SelectHelper::Select() to
   // set the file descriptors that we will watch for when calling
   // select. This will cause FD_SET() to be called prior to calling select
   // using the "fd" provided.
-  void FDSetRead(int fd);
-  void FDSetWrite(int fd);
-  void FDSetError(int fd);
+  void FDSetRead(lldb::socket_t fd);
+  void FDSetWrite(lldb::socket_t fd);
+  void FDSetError(lldb::socket_t fd);
 
   // Call the FDIsSet*() functions after calling SelectHelper::Select()
   // to check which file descriptors are ready for read/write/error. This
   // will contain the result of FD_ISSET after calling select for a given
   // file descriptor.
-  bool FDIsSetRead(int fd) const;
-  bool FDIsSetWrite(int fd) const;
-  bool FDIsSetError(int fd) const;
+  bool FDIsSetRead(lldb::socket_t fd) const;
+  bool FDIsSetWrite(lldb::socket_t fd) const;
+  bool FDIsSetError(lldb::socket_t fd) const;
 
   // Call the system's select() to wait for descriptors using
   // timeout provided in a call the SelectHelper::SetTimeout(),
   // or infinite wait if no timeout was set.
   lldb_private::Error Select();
 
 protected:
   struct FDInfo {
     FDInfo()
         : read_set(false), write_set(false), error_set(false),
           read_is_set(false), write_is_set(false), error_is_set(false) {}
 
     void PrepareForSelect() {
       read_is_set = false;
       write_is_set = false;
       error_is_set = false;
     }
 
     bool read_set : 1, write_set : 1, error_set : 1, read_is_set : 1,
         write_is_set : 1, error_is_set : 1;
   };
-  llvm::DenseMap<int, FDInfo> m_fd_map;
+  llvm::DenseMap<lldb::socket_t, FDInfo> m_fd_map;
   llvm::Optional<std::chrono::steady_clock::time_point> m_end_time;
 };
 
 #endif // liblldb_SelectHelper_h_

source/Core/Mangled.cpp

#if defined(_MSC_VER)
                                                  // specifiers
                 UNDNAME_NO_MS_KEYWORDS // Strip all MS extension keywords
             );
         if (log) {
           if (demangled_name && demangled_name[0])
             log->Printf("demangled msvc: %s -> \"%s\"", mangled_name,
                         demangled_name);
           else
-            log->Printf("demangled msvc: %s -> error: 0x%" PRIx64, mangled_name,
+            log->Printf("demangled msvc: %s -> error: 0x%lu", mangled_name,
                         result);
         }
 
         if (result == 0) {
           free(demangled_name);
           demangled_name = nullptr;
         }
 #endif

source/Core/SourceManager.cpp

if (m_offsets.empty()) {
                 if (curr_ch != next_ch)
                   ++s;
               }
             }
             m_offsets.push_back(s + 1 - start);
           }
         }
         if (!m_offsets.empty()) {
-          if (m_offsets.back() < end - start)
+          if (m_offsets.back() < size_t(end - start))
             m_offsets.push_back(end - start);
         }
         return true;
       }
     } else {
       // Some lines have been populated, start where we last left off
       assert("Not implemented yet" && false);
     }

source/DataFormatters/StringPrinter.cpp

 StringPrinter::StringPrinterBufferPointer<>
 GetPrintableImpl<StringPrinter::StringElementType::UTF8>(uint8_t *buffer,
                                                          uint8_t *buffer_end,
                                                          uint8_t *&next) {
   StringPrinter::StringPrinterBufferPointer<> retval{nullptr};
 
   unsigned utf8_encoded_len = llvm::getNumBytesForUTF8(*buffer);
 
-  if (1 + buffer_end - buffer < utf8_encoded_len) {
+  if (1u + std::distance(buffer, buffer_end) < utf8_encoded_len) {
     // I don't have enough bytes - print whatever I have left
     retval = {buffer, static_cast<size_t>(1 + buffer_end - buffer)};
     next = buffer_end + 1;
     return retval;
   }
 
   char32_t codepoint = 0;
   switch (utf8_encoded_len) {

source/Host/common/NativeBreakpointList.cpp

 NativeBreakpointList::NativeBreakpointList() : m_mutex() {}
 
 Error NativeBreakpointList::AddRef(lldb::addr_t addr, size_t size_hint,
                                    bool hardware,
                                    CreateBreakpointFunc create_func) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   if (log)
     log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64
-                ", size_hint = %lu, hardware = %s",
+                ", size_hint = %zu, hardware = %s",
                 __FUNCTION__, addr, size_hint, hardware ? "true" : "false");
 
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   // Check if the breakpoint is already set.
   auto iter = m_breakpoints.find(addr);
   if (iter != m_breakpoints.end()) {
     // Yes - bump up ref count.
     if (log)
       log->Printf("NativeBreakpointList::%s addr = 0x%" PRIx64
                   " -- already enabled, upping ref count",
                   __FUNCTION__, addr);
 
     iter->second->AddRef();
     return Error();
   }
 
   // Create a new breakpoint using the given create func.
   if (log)
     log->Printf(
         "NativeBreakpointList::%s creating breakpoint for addr = 0x%" PRIx64
-        ", size_hint = %lu, hardware = %s",
+        ", size_hint = %zu, hardware = %s",
         __FUNCTION__, addr, size_hint, hardware ? "true" : "false");
 
   NativeBreakpointSP breakpoint_sp;
   Error error = create_func(addr, size_hint, hardware, breakpoint_sp);
   if (error.Fail()) {
     if (log)
       log->Printf(
           "NativeBreakpointList::%s creating breakpoint for addr = 0x%" PRIx64
-          ", size_hint = %lu, hardware = %s -- FAILED: %s",
+          ", size_hint = %zu, hardware = %s -- FAILED: %s",
           __FUNCTION__, addr, size_hint, hardware ? "true" : "false",
           error.AsCString());
     return error;
   }
 
   // Remember the breakpoint.
   assert(breakpoint_sp && "NativeBreakpoint create function succeeded but "
                           "returned NULL breakpoint");

source/Host/common/ProcessRunLock.cpp

 #ifndef _WIN32
-
 #include "lldb/Host/ProcessRunLock.h"
 
 namespace lldb_private {
 
 ProcessRunLock::ProcessRunLock() : m_running(false) {
   int err = ::pthread_rwlock_init(&m_rwlock, NULL);
   (void)err;
   //#if LLDB_CONFIGURATION_DEBUG

source/Host/common/SocketAddress.cpp

const char *inet_ntop(int af, const void *src, char *dst, socklen_t size) {
   if (size == 0) {
     return nullptr;
   }
 
   switch (af) {
   case AF_INET: {
     {
       const char *formatted = inet_ntoa(*static_cast<const in_addr *>(src));
-      if (formatted && strlen(formatted) < size) {
+      if (formatted && strlen(formatted) < static_cast<size_t>(size)) {
         return ::strcpy(dst, formatted);
       }
     }
     return nullptr;
   case AF_INET6: {
     char tmp[INET6_ADDRSTRLEN] = {0};
     const uint16_t *src16 = static_cast<const uint16_t *>(src);
     int full_size = ::snprintf(

source/Host/common/SoftwareBreakpoint.cpp

if (bp_opcode_size == 0) {
     return Error("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
                  "returned zero, unable to get breakpoint trap for address "
                  "0x%" PRIx64,
                  addr);
   }
 
   if (bp_opcode_size > MAX_TRAP_OPCODE_SIZE) {
     if (log)
-      log->Printf("SoftwareBreakpoint::%s cannot support %lu trapcode bytes, "
-                  "max size is %lu",
+      log->Printf("SoftwareBreakpoint::%s cannot support %zu trapcode bytes, "
+                  "max size is %zu",
                   __FUNCTION__, bp_opcode_size, MAX_TRAP_OPCODE_SIZE);
     return Error("SoftwareBreakpoint::GetSoftwareBreakpointTrapOpcode() "
-                 "returned too many trap opcode bytes: requires %lu but we "
-                 "only support a max of %lu",
+                 "returned too many trap opcode bytes: requires %zu but we "
+                 "only support a max of %zu",
                  bp_opcode_size, MAX_TRAP_OPCODE_SIZE);
   }
 
   // Validate that we received opcodes.
   if (!bp_opcode_bytes) {
     if (log)
       log->Printf("SoftwareBreakpoint::%s failed to retrieve trap opcode bytes",
                   __FUNCTION__);
if (log)
                   __FUNCTION__, error.AsCString());
     return error;
   }
 
   // Ensure we read as many bytes as we expected.
   if (bytes_read != bp_opcode_size) {
     if (log)
       log->Printf("SoftwareBreakpoint::%s failed to read memory while "
-                  "attempting to set breakpoint: attempted to read %lu bytes "
-                  "but only read %" PRIu64,
-                  __FUNCTION__, bp_opcode_size, (uint64_t)bytes_read);
+                  "attempting to set breakpoint: attempted to read %zu bytes "
+                  "but only read %zu",
+                  __FUNCTION__, bp_opcode_size, bytes_read);
     return Error("SoftwareBreakpoint::%s failed to read memory while "
-                 "attempting to set breakpoint: attempted to read %lu bytes "
-                 "but only read %" PRIu64,
-                 __FUNCTION__, bp_opcode_size, (uint64_t)bytes_read);
+                 "attempting to set breakpoint: attempted to read %zu bytes "
+                 "but only read %zu",
+                 __FUNCTION__, bp_opcode_size, bytes_read);
   }
 
   // Log what we read.
   if (log) {
     int i = 0;
     for (const uint8_t *read_byte = saved_opcode_bytes;
          read_byte < saved_opcode_bytes + bp_opcode_size; ++read_byte) {
       log->Printf("SoftwareBreakpoint::%s addr = 0x%" PRIx64
if (log)
                   __FUNCTION__, error.AsCString());
     return error;
   }
 
   // Ensure we wrote as many bytes as we expected.
   if (bytes_written != bp_opcode_size) {
     error.SetErrorStringWithFormat(
         "SoftwareBreakpoint::%s failed write memory while attempting to set "
-        "breakpoint: attempted to write %lu bytes but only wrote %" PRIu64,
-        __FUNCTION__, bp_opcode_size, (uint64_t)bytes_written);
+        "breakpoint: attempted to write %zu bytes but only wrote %zu",
+        __FUNCTION__, bp_opcode_size, bytes_written);
     if (log)
       log->PutCString(error.AsCString());
     return error;
   }
 
   uint8_t verify_bp_opcode_bytes[MAX_TRAP_OPCODE_SIZE];
   size_t verify_bytes_read = 0;
   error = process.ReadMemory(addr, verify_bp_opcode_bytes, bp_opcode_size,
                              verify_bytes_read);
   if (error.Fail()) {
     if (log)
       log->Printf("SoftwareBreakpoint::%s failed to read memory while "
                   "attempting to verify the breakpoint set: %s",
                   __FUNCTION__, error.AsCString());
     return error;
   }
 
   // Ensure we read as many verification bytes as we expected.
   if (verify_bytes_read != bp_opcode_size) {
     if (log)
       log->Printf("SoftwareBreakpoint::%s failed to read memory while "
-                  "attempting to verify breakpoint: attempted to read %lu "
-                  "bytes but only read %" PRIu64,
-                  __FUNCTION__, bp_opcode_size, (uint64_t)verify_bytes_read);
+                  "attempting to verify breakpoint: attempted to read %zu "
+                  "bytes but only read %zu",
+                  __FUNCTION__, bp_opcode_size, verify_bytes_read);
     return Error("SoftwareBreakpoint::%s failed to read memory while "
-                 "attempting to verify breakpoint: attempted to read %lu bytes "
-                 "but only read %" PRIu64,
-                 __FUNCTION__, bp_opcode_size, (uint64_t)verify_bytes_read);
+                 "attempting to verify breakpoint: attempted to read %zu bytes "
+                 "but only read %zu",
+                 __FUNCTION__, bp_opcode_size, verify_bytes_read);
   }
 
   if (::memcmp(bp_opcode_bytes, verify_bp_opcode_bytes, bp_opcode_size) != 0) {
     if (log)
       log->Printf("SoftwareBreakpoint::%s: verification of software breakpoint "
                   "writing failed - trap opcodes not successfully read back "
                   "after writing when setting breakpoint at 0x%" PRIx64,
                   __FUNCTION__, addr);
if (m_opcode_size > 0) {
 
     // Read the breakpoint opcode
     size_t bytes_read = 0;
     error =
         m_process.ReadMemory(m_addr, curr_break_op, m_opcode_size, bytes_read);
     if (error.Success() && bytes_read < m_opcode_size) {
       error.SetErrorStringWithFormat(
           "SoftwareBreakpointr::%s addr=0x%" PRIx64
-          ": tried to read %lu bytes but only read %" PRIu64,
-          __FUNCTION__, m_addr, m_opcode_size, (uint64_t)bytes_read);
+          ": tried to read %zu bytes but only read %zu",
+          __FUNCTION__, m_addr, m_opcode_size, bytes_read);
     }
     if (error.Success()) {
       bool verify = false;
       // Make sure the breakpoint opcode exists at this address
       if (::memcmp(curr_break_op, m_trap_opcodes, m_opcode_size) == 0) {
         break_op_found = true;
         // We found a valid breakpoint opcode at this address, now restore
         // the saved opcode.
         size_t bytes_written = 0;
         error = m_process.WriteMemory(m_addr, m_saved_opcodes, m_opcode_size,
                                       bytes_written);
         if (error.Success() && bytes_written < m_opcode_size) {
           error.SetErrorStringWithFormat(
               "SoftwareBreakpoint::%s addr=0x%" PRIx64
-              ": tried to write %lu bytes but only wrote %" PRIu64,
-              __FUNCTION__, m_addr, m_opcode_size, (uint64_t)bytes_written);
+              ": tried to write %zu bytes but only wrote %zu",
+              __FUNCTION__, m_addr, m_opcode_size, bytes_written);
         }
         if (error.Success()) {
           verify = true;
         }
       } else {
         error.SetErrorString(
             "Original breakpoint trap is no longer in memory.");
         // Set verify to true and so we can check if the original opcode has
         // already been restored
         verify = true;
       }
 
       if (verify) {
         uint8_t verify_opcode[MAX_TRAP_OPCODE_SIZE];
         assert(m_opcode_size <= sizeof(verify_opcode));
         // Verify that our original opcode made it back to the inferior
 
         size_t verify_bytes_read = 0;
         error = m_process.ReadMemory(m_addr, verify_opcode, m_opcode_size,
                                      verify_bytes_read);
         if (error.Success() && verify_bytes_read < m_opcode_size) {
           error.SetErrorStringWithFormat(
               "SoftwareBreakpoint::%s addr=0x%" PRIx64
-              ": tried to read %lu verification bytes but only read %" PRIu64,
-              __FUNCTION__, m_addr, m_opcode_size, (uint64_t)verify_bytes_read);
+              ": tried to read %zu verification bytes but only read %zu",
+              __FUNCTION__, m_addr, m_opcode_size, verify_bytes_read);
         }
         if (error.Success()) {
           // compare the memory we just read with the original opcode
           if (::memcmp(m_saved_opcodes, verify_opcode, m_opcode_size) == 0) {
             // SUCCESS
             if (log) {
               int i = 0;
               for (const uint8_t *verify_byte = verify_opcode;

source/Host/common/UDPSocket.cpp

Error UDPSocket::Connect(llvm::StringRef name, bool child_processes_inherit,
 
   ::memset(&hints, 0, sizeof(hints));
   hints.ai_family = kDomain;
   hints.ai_socktype = kType;
   int err = ::getaddrinfo(host_str.c_str(), port_str.c_str(), &hints,
                           &service_info_list);
   if (err != 0) {
     error.SetErrorStringWithFormat(
+#if defined(_MSC_VER) && defined(UNICODE)
+        "getaddrinfo(%s, %s, &hints, &info) returned error %i (%S)",
+#else
         "getaddrinfo(%s, %s, &hints, &info) returned error %i (%s)",
+#endif
         host_str.c_str(), port_str.c_str(), err, gai_strerror(err));
     return error;
   }
 
   for (struct addrinfo *service_info_ptr = service_info_list;
        service_info_ptr != nullptr;
        service_info_ptr = service_info_ptr->ai_next) {
     auto send_fd = CreateSocket(

source/Host/windows/ConnectionGenericFileWindows.cpp

finish:
   // kBytesAvailableEvent is a manual reset event.  Make sure it gets reset here
   // so that any
   // subsequent operations don't immediately see bytes available.
   ResetEvent(m_event_handles[kBytesAvailableEvent]);
 
   IncrementFilePointer(return_info.GetBytes());
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log) {
-    log->Printf("%" PRIxPTR " ConnectionGenericFile::Read()  handle = %" PRIxPTR
-                ", dst = %" PRIxPTR ", dst_len = %" PRIu64 ") => %" PRIu64
-                ", error = %s",
-                this, m_file, dst, static_cast<uint64_t>(dst_len),
-                static_cast<uint64_t>(return_info.GetBytes()),
+    log->Printf("%p ConnectionGenericFile::Read()  handle = %p, dst = %p, "
+                "dst_len = %zu) => %zu, error = %s",
+                this, m_file, dst, dst_len, return_info.GetBytes(),
                 return_info.GetError().AsCString());
   }
 
   return return_info.GetBytes();
 }
 
 size_t ConnectionGenericFile::Write(const void *src, size_t src_len,
                                     lldb::ConnectionStatus &status,

 finish:
   status = return_info.GetStatus();
   if (error_ptr)
     *error_ptr = return_info.GetError();
 
   IncrementFilePointer(return_info.GetBytes());
   Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
   if (log) {
-    log->Printf("%" PRIxPTR
-                " ConnectionGenericFile::Write()  handle = %" PRIxPTR
-                ", src = %" PRIxPTR ", src_len = %" PRIu64 ") => %" PRIu64
-                ", error = %s",
-                this, m_file, src, static_cast<uint64_t>(src_len),
-                static_cast<uint64_t>(return_info.GetBytes()),
+    log->Printf("%p ConnectionGenericFile::Write()  handle = %p, src = %p, "
+                "src_len = %zu) => %zu, error = %s",
+                this, m_file, src, src_len, return_info.GetBytes(),
                 return_info.GetError().AsCString());
   }
   return return_info.GetBytes();
 }
 
 std::string ConnectionGenericFile::GetURI() { return m_uri; }
 
 bool ConnectionGenericFile::InterruptRead() {

source/Host/windows/EditLineWin.cpp

int el_set(EditLine *el, int code, ...) {
   } break;
   case (EL_BIND): {
     // EL_BIND, const char *, ..., NULL
     //      perform the BIND built-in command.  Refer to editrc(5) for more
     //      information.
 
     const char *name = va_arg(vl, const char *);
 
-    for (int i = 0; i < _bindings.size(); i++) {
-      el_binding *bind = _bindings[i];
+    for (auto bind : _bindings) {
       if (strcmp(bind->name, name) == 0) {
         bind->key = va_arg(vl, const char *);
         break;
       }
     }
 
   } break;
   case (EL_CLIENTDATA): {

source/Host/windows/FileSystem.cpp

if (!recurse) {
     // SHFileOperation() accepts a list of paths, and so must be
     // double-null-terminated to
     // indicate the end of the list. The first null terminator is there only in
     // the backing
     // store but not the actual vector contents, and so we need to push twice.
     path_buffer.push_back(0);
     path_buffer.push_back(0);
 
-    SHFILEOPSTRUCTW shfos = {0};
+    SHFILEOPSTRUCTW shfos = {};
     shfos.wFunc = FO_DELETE;
     shfos.pFrom = (LPCWSTR)path_buffer.data();
     shfos.fFlags = FOF_NO_UI;
 
     int result = ::SHFileOperationW(&shfos);
     // TODO(zturner): Correctly handle the intricacies of SHFileOperation return
     // values.
     if (result != 0)

source/Host/windows/Host.cpp

 uint32_t Host::FindProcesses(const ProcessInstanceInfoMatch &match_info,
                              ProcessInstanceInfoList &process_infos) {
   process_infos.Clear();
 
   AutoHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
   if (!snapshot.IsValid())
     return 0;
 
-  PROCESSENTRY32W pe = {0};
+  PROCESSENTRY32W pe = {};
   pe.dwSize = sizeof(PROCESSENTRY32W);
   if (Process32FirstW(snapshot.get(), &pe)) {
     do {
       AutoHandle handle(::OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE,
                                       pe.th32ProcessID),
                         nullptr);
 
       ProcessInstanceInfo process;

source/Host/windows/LockFileWindows.cpp

 
 namespace {
 
 Error fileLock(HANDLE file_handle, DWORD flags, const uint64_t start,
                const uint64_t len) {
   if (start != 0)
     return Error("Non-zero start lock regions are not supported");
 
-  OVERLAPPED overlapped = {0};
+  OVERLAPPED overlapped = {};
 
   if (!::LockFileEx(file_handle, flags, 0, len, 0, &overlapped) &&
       ::GetLastError() != ERROR_IO_PENDING)
     return Error(::GetLastError(), eErrorTypeWin32);
 
   DWORD bytes;
   if (!::GetOverlappedResult(file_handle, &overlapped, &bytes, TRUE))
     return Error(::GetLastError(), eErrorTypeWin32);
Error LockFileWindows::DoReadLock(const uint64_t start, const uint64_t len) {
   return fileLock(m_file, 0, start, len);
 }
 
 Error LockFileWindows::DoTryReadLock(const uint64_t start, const uint64_t len) {
   return fileLock(m_file, LOCKFILE_FAIL_IMMEDIATELY, start, len);
 }
 
 Error LockFileWindows::DoUnlock() {
-  OVERLAPPED overlapped = {0};
+  OVERLAPPED overlapped = {};
 
   if (!::UnlockFileEx(m_file, 0, m_len, 0, &overlapped) &&
       ::GetLastError() != ERROR_IO_PENDING)
     return Error(::GetLastError(), eErrorTypeWin32);
 
   DWORD bytes;
   if (!::GetOverlappedResult(m_file, &overlapped, &bytes, TRUE))
     return Error(::GetLastError(), eErrorTypeWin32);
 
   return Error();
 }

source/Host/windows/PipeWindows.cpp

 
 Error PipeWindows::OpenNamedPipe(llvm::StringRef name,
                                  bool child_process_inherit, bool is_read) {
   if (name.empty())
     return Error(ERROR_INVALID_PARAMETER, eErrorTypeWin32);
 
   assert(is_read ? !CanRead() : !CanWrite());
 
-  SECURITY_ATTRIBUTES attributes = {0};
+  SECURITY_ATTRIBUTES attributes = {};
   attributes.bInheritHandle = child_process_inherit;
 
   std::string pipe_path = "\\\\.\\Pipe\\";
   pipe_path.append(name);
 
   if (is_read) {
     m_read = ::CreateFileA(pipe_path.c_str(), GENERIC_READ, 0, &attributes,
                            OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);

source/Host/windows/ProcessLauncherWindows.cpp

 using namespace lldb_private;
 
 namespace {
 void CreateEnvironmentBuffer(const Args &env, std::vector<char> &buffer) {
   if (env.GetArgumentCount() == 0)
     return;
 
   // Environment buffer is a null terminated list of null terminated strings
-  for (int i = 0; i < env.GetArgumentCount(); ++i) {
+  for (size_t i = 0; i < env.GetArgumentCount(); ++i) {
     std::wstring warg;
     if (llvm::ConvertUTF8toWide(env.GetArgumentAtIndex(i), warg)) {
       buffer.insert(buffer.end(), (char *)warg.c_str(),
                     (char *)(warg.c_str() + warg.size() + 1));
     }
   }
   // One null wchar_t (to end the block) is two null bytes
   buffer.push_back(0);
   buffer.push_back(0);
 }
 }
 
 HostProcess
 ProcessLauncherWindows::LaunchProcess(const ProcessLaunchInfo &launch_info,
                                       Error &error) {
   error.Clear();
 
   std::string executable;
   std::string commandLine;
   std::vector<char> environment;
-  STARTUPINFO startupinfo = {0};
-  PROCESS_INFORMATION pi = {0};
+  STARTUPINFO startupinfo = {};
+  PROCESS_INFORMATION pi = {};
 
   HANDLE stdin_handle = GetStdioHandle(launch_info, STDIN_FILENO);
   HANDLE stdout_handle = GetStdioHandle(launch_info, STDOUT_FILENO);
   HANDLE stderr_handle = GetStdioHandle(launch_info, STDERR_FILENO);
 
   startupinfo.cb = sizeof(startupinfo);
   startupinfo.dwFlags |= STARTF_USESTDHANDLES;
   startupinfo.hStdError =

 }
 
 HANDLE
 ProcessLauncherWindows::GetStdioHandle(const ProcessLaunchInfo &launch_info,
                                        int fd) {
   const FileAction *action = launch_info.GetFileActionForFD(fd);
   if (action == nullptr)
     return NULL;
-  SECURITY_ATTRIBUTES secattr = {0};
+  SECURITY_ATTRIBUTES secattr = {};
   secattr.nLength = sizeof(SECURITY_ATTRIBUTES);
   secattr.bInheritHandle = TRUE;
 
   llvm::StringRef path = action->GetPath();
   DWORD access = 0;
   DWORD share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
   DWORD create = 0;
   DWORD flags = 0;

source/Host/windows/ProcessRunLock.cpp

 
 using namespace lldb_private;
 
 ProcessRunLock::ProcessRunLock() : m_running(false) {
   m_rwlock = new SRWLOCK;
   InitializeSRWLock(GetLock(m_rwlock));
 }
 
-ProcessRunLock::~ProcessRunLock() { delete m_rwlock; }
+ProcessRunLock::~ProcessRunLock() { delete static_cast<SRWLOCK *>(m_rwlock); }
 
 bool ProcessRunLock::ReadTryLock() {
   ::ReadLock(m_rwlock);
   if (m_running == false)
     return true;
   ::ReadUnlock(m_rwlock);
   return false;
 }

source/Interpreter/Args.cpp

 void Args::UpdateArgsAfterOptionParsing() {
   assert(!m_argv.empty());
   assert(m_argv.back() == nullptr);
 
   // Now m_argv might be out of date with m_entries, so we need to fix that.
   // This happens because getopt_long_only may permute the order of the
   // arguments in argv, so we need to re-order the quotes and the refs array
   // to match.
-  for (int i = 0; i < m_argv.size() - 1; ++i) {
+  for (size_t i = 0; i < m_argv.size() - 1; ++i) {
     const char *argv = m_argv[i];
     auto pos =
         std::find_if(m_entries.begin() + i, m_entries.end(),
                      [argv](const ArgEntry &D) { return D.c_str() == argv; });
     assert(pos != m_entries.end());
     size_t distance = std::distance(m_entries.begin(), pos);
     if (i == distance)
       continue;

 }
 
 void Args::AppendArguments(const char **argv) {
   size_t argc = ArgvToArgc(argv);
 
   assert(m_argv.size() == m_entries.size() + 1);
   assert(m_argv.back() == nullptr);
   m_argv.pop_back();
-  for (int i = 0; i < argc; ++i) {
-    m_entries.emplace_back(argv[i], '\0');
+  for (auto arg : llvm::makeArrayRef(argv, argc)) {
+    m_entries.emplace_back(arg, '\0');
     m_argv.push_back(m_entries.back().data());
   }
 
   m_argv.push_back(nullptr);
 }
 
 llvm::StringRef Args::AppendArgument(llvm::StringRef arg_str, char quote_char) {
   return InsertArgumentAtIndex(GetArgumentCount(), arg_str, quote_char);

 }
 
 void Args::SetArguments(size_t argc, const char **argv) {
   Clear();
 
   auto args = llvm::makeArrayRef(argv, argc);
   m_entries.resize(argc);
   m_argv.resize(argc + 1);
-  for (int i = 0; i < args.size(); ++i) {
+  for (size_t i = 0; i < args.size(); ++i) {
     char quote =
         ((args[i][0] == '\'') || (args[i][0] == '"') || (args[i][0] == '`'))
             ? args[i][0]
             : '\0';
 
     m_entries[i] = ArgEntry(args[i], quote);
     m_argv[i] = m_entries[i].data();
   }

source/Interpreter/CommandInterpreter.cpp

void CommandInterpreter::OutputHelpText(Stream &strm, const char *word_text,
 
   size_t len = text_strm.GetSize();
   const char *text = text_strm.GetData();
 
   uint32_t chars_left = max_columns;
 
   for (uint32_t i = 0; i < len; i++) {
     if ((text[i] == ' ' && ::strchr((text + i + 1), ' ') &&
-         chars_left < ::strchr((text + i + 1), ' ') - (text + i)) ||
+         chars_left < static_cast<uint32_t>(::strchr((text + i + 1), ' ') -
+                                            (text + i))) ||
         text[i] == '\n') {
       chars_left = max_columns - indent_size;
       strm.EOL();
       strm.Indent();
     } else {
       strm.PutChar(text[i]);
       chars_left--;
     }

source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp

bool ObjectContainerUniversalMachO::ParseHeader(
   return success;
 }
 
 void ObjectContainerUniversalMachO::Dump(Stream *s) const {
   s->Printf("%p: ", static_cast<const void *>(this));
   s->Indent();
   const size_t num_archs = GetNumArchitectures();
   const size_t num_objects = GetNumObjects();
-  s->Printf("ObjectContainerUniversalMachO, num_archs = %lu, num_objects = %lu",
+  s->Printf("ObjectContainerUniversalMachO, num_archs = %zu, num_objects = %zu",
             num_archs, num_objects);
   uint32_t i;
   ArchSpec arch;
   s->IndentMore();
   for (i = 0; i < num_archs; i++) {
     s->Indent();
     GetArchitectureAtIndex(i, arch);
     s->Printf("arch[%u] = %s\n", i, arch.GetArchitectureName());

source/Plugins/Process/Windows/Common/RegisterContextWindows.cpp

bool RegisterContextWindows::CacheAllRegisterValues() {
   TargetThreadWindows &wthread = static_cast<TargetThreadWindows &>(m_thread);
   memset(&m_context, 0, sizeof(m_context));
   m_context.ContextFlags = kWinContextFlags;
   if (!::GetThreadContext(
           wthread.GetHostThread().GetNativeThread().GetSystemHandle(),
           &m_context)) {
     WINERR_IFALL(
         WINDOWS_LOG_REGISTERS,
-        "GetThreadContext failed with error %u while caching register values.",
+        "GetThreadContext failed with error %lu while caching register values.",
         ::GetLastError());
     return false;
   }
   WINLOG_IFALL(WINDOWS_LOG_REGISTERS,
-               "GetThreadContext successfully updated the register values.",
-               ::GetLastError());
+               "GetThreadContext successfully updated the register values.");
   m_context_stale = false;
   return true;
 }

source/Plugins/Process/Windows/Common/x86/RegisterContextWindows_x86.cpp

RegisterInfo g_register_infos[] = {
     //  VALUE REGS    INVALIDATE REGS
     //  ==============================  =======================
     //  ===================  =========================  ===================
     //  =================  ==========    ===============
     {DEFINE_GPR(eax, nullptr),
      {ehframe_eax_i386, dwarf_eax_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_eax_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(ebx, nullptr),
      {ehframe_ebx_i386, dwarf_ebx_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_ebx_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(ecx, nullptr),
      {ehframe_ecx_i386, dwarf_ecx_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_ecx_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(edx, nullptr),
      {ehframe_edx_i386, dwarf_edx_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_edx_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(edi, nullptr),
      {ehframe_edi_i386, dwarf_edi_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_edi_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(esi, nullptr),
      {ehframe_esi_i386, dwarf_esi_i386, LLDB_INVALID_REGNUM,
       LLDB_INVALID_REGNUM, lldb_esi_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(ebp, "fp"),
      {ehframe_ebp_i386, dwarf_ebp_i386, LLDB_REGNUM_GENERIC_FP,
       LLDB_INVALID_REGNUM, lldb_ebp_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(esp, "sp"),
      {ehframe_esp_i386, dwarf_esp_i386, LLDB_REGNUM_GENERIC_SP,
       LLDB_INVALID_REGNUM, lldb_esp_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR(eip, "pc"),
      {ehframe_eip_i386, dwarf_eip_i386, LLDB_REGNUM_GENERIC_PC,
       LLDB_INVALID_REGNUM, lldb_eip_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
     {DEFINE_GPR_BIN(eflags, "flags"),
      {ehframe_eflags_i386, dwarf_eflags_i386, LLDB_REGNUM_GENERIC_FLAGS,
       LLDB_INVALID_REGNUM, lldb_eflags_i386},
      nullptr,
-     nullptr},
+     nullptr,
+     nullptr,
+     0u},
 };
 static size_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
 
 // Array of lldb register numbers used to define the set of all General Purpose
 // Registers
 uint32_t g_gpr_reg_indices[] = {eRegisterIndexEax, eRegisterIndexEbx,
                                 eRegisterIndexEcx, eRegisterIndexEdx,
                                 eRegisterIndexEdi, eRegisterIndexEsi,

 bool RegisterContextWindows_x86::ReadRegisterHelper(
     DWORD flags_required, const char *reg_name, DWORD value,
     RegisterValue &reg_value) const {
   if ((m_context.ContextFlags & flags_required) != flags_required) {
     WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Thread context doesn't have %s",
                  reg_name);
     return false;
   }
-  WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%x from %s", value,
+  WINLOG_IFALL(WINDOWS_LOG_REGISTERS, "Read value 0x%lx from %s", value,
                reg_name);
   reg_value.SetUInt32(value);
   return true;
 }

source/Plugins/Process/Windows/Live/DebuggerThread.h

DWORD HandleUnloadDllEvent(const UNLOAD_DLL_DEBUG_INFO &info,
                              DWORD thread_id);
   DWORD HandleODSEvent(const OUTPUT_DEBUG_STRING_INFO &info, DWORD thread_id);
   DWORD HandleRipEvent(const RIP_INFO &info, DWORD thread_id);
 
   DebugDelegateSP m_debug_delegate;
 
   HostProcess m_process;    // The process being debugged.
   HostThread m_main_thread; // The main thread of the inferior.
-  HANDLE m_image_file;      // The image file of the process being debugged.
 
-  ExceptionRecordSP
-      m_active_exception; // The current exception waiting to be handled
+  // The image file of the process being debugged.
+  HANDLE m_image_file = nullptr;
 
-  Predicate<ExceptionResult>
-      m_exception_pred; // A predicate which gets signalled when an exception
-                        // is finished processing and the debug loop can be
-                        // continued.
-
-  HANDLE m_debugging_ended_event; // An event which gets signalled by the
-                                  // debugger thread when it
-  // exits the debugger loop and is detached from the inferior.
-
-  std::atomic<DWORD> m_pid_to_detach;   // Signals the loop to detach from the
-                                        // process (specified by pid).
-  std::atomic<bool> m_is_shutting_down; // Signals the debug loop to stop
-                                        // processing certain types of
-                                        // events that block shutdown.
-  bool m_detached; // Indicates we've detached from the inferior process and the
-                   // debug loop can exit.
+  // The current exception waiting to be handled
+  ExceptionRecordSP m_active_exception;
+
+  // A predicate which gets signalled when an exception is finished processing
+  // and the debug loop can be continued.
+  Predicate<ExceptionResult> m_exception_pred;
+
+  // An event which gets signalled by the debugger thread when it exits the
+  // debugger loop and is detached from the inferior.
+  HANDLE m_debugging_ended_event = nullptr;
+
+  // Signals the loop to detach from the process (specified by pid).
+  std::atomic<DWORD> m_pid_to_detach;
+
+  // Signals the debug loop to stop processing certain types of events that
+  // block shutdown.
+  std::atomic<bool> m_is_shutting_down;
+
+  // Indicates we've detached from the inferior process and the debug loop can
+  // exit.
+  bool m_detached = false;
 
   static lldb::thread_result_t DebuggerThreadLaunchRoutine(void *data);
   lldb::thread_result_t
   DebuggerThreadLaunchRoutine(const ProcessLaunchInfo &launch_info);
   static lldb::thread_result_t DebuggerThreadAttachRoutine(void *data);
   lldb::thread_result_t
   DebuggerThreadAttachRoutine(lldb::pid_t pid,
                               const ProcessAttachInfo &launch_info);
 };
 }
-
 #endif

source/Plugins/Process/Windows/Live/DebuggerThread.cpp

DebugAttachContext(DebuggerThread *thread, lldb::pid_t pid,
       : m_thread(thread), m_pid(pid), m_attach_info(attach_info) {}
   DebuggerThread *m_thread;
   lldb::pid_t m_pid;
   ProcessAttachInfo m_attach_info;
 };
 }
 
 DebuggerThread::DebuggerThread(DebugDelegateSP debug_delegate)
-    : m_debug_delegate(debug_delegate), m_image_file(nullptr),
-      m_debugging_ended_event(nullptr), m_is_shutting_down(false),
-      m_pid_to_detach(0), m_detached(false) {
+    : m_debug_delegate(debug_delegate), m_pid_to_detach(0),
+      m_is_shutting_down(false) {
   m_debugging_ended_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
 }
 
 DebuggerThread::~DebuggerThread() { ::CloseHandle(m_debugging_ended_event); }
 
 Error DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info) {
   WINLOG_IFALL(WINDOWS_LOG_PROCESS,
                "DebuggerThread::DebugLaunch launching '%s'",
Error DebuggerThread::DebugLaunch(const ProcessLaunchInfo &launch_info) {
   }
 
   return error;
 }
 
 Error DebuggerThread::DebugAttach(lldb::pid_t pid,
                                   const ProcessAttachInfo &attach_info) {
   WINLOG_IFALL(WINDOWS_LOG_PROCESS,
-               "DebuggerThread::DebugAttach attaching to '%u'", (DWORD)pid);
+               "DebuggerThread::DebugAttach attaching to '%llu'", pid);
 
   Error error;
   DebugAttachContext *context = new DebugAttachContext(this, pid, attach_info);
   HostThread slave_thread(ThreadLauncher::LaunchThread(
       "lldb.plugin.process-windows.slave[?]", DebuggerThreadAttachRoutine,
       context, &error));
 
   if (!error.Success()) {
     WINERR_IFALL(WINDOWS_LOG_PROCESS,
-                 "DebugAttach couldn't attach to process '%u'.  %s", (DWORD)pid,
+                 "DebugAttach couldn't attach to process '%llu'.  %s", pid,
                  error.AsCString());
   }
 
   return error;
 }
 
 lldb::thread_result_t DebuggerThread::DebuggerThreadLaunchRoutine(void *data) {
   DebugLaunchContext *context = static_cast<DebugLaunchContext *>(data);

 lldb::thread_result_t DebuggerThread::DebuggerThreadAttachRoutine(
     lldb::pid_t pid, const ProcessAttachInfo &attach_info) {
   // Grab a shared_ptr reference to this so that we know it won't get deleted
   // until after the
   // thread routine has exited.
   std::shared_ptr<DebuggerThread> this_ref(shared_from_this());
 
   WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DebuggerThread preparing to attach to "
-                                    "process '%u' on background thread.",
-               (DWORD)pid);
+                                    "process '%llu' on background thread.",
+               pid);
 
   if (!DebugActiveProcess((DWORD)pid)) {
     Error error(::GetLastError(), eErrorTypeWin32);
     m_debug_delegate->OnDebuggerError(error, 0);
     return 0;
   }
 
   // The attach was successful, enter the debug loop.  From here on out, this is
if (!terminate) {
     // Force a fresh break so that the detach can happen from the debugger
     // thread.
     if (!::DebugBreakProcess(
             GetProcess().GetNativeProcess().GetSystemHandle())) {
       error.SetError(::GetLastError(), eErrorTypeWin32);
     }
   }
 
-  WINLOG_IFALL(WINDOWS_LOG_PROCESS,
-               "StopDebugging waiting for detach from process %u to complete.",
-               pid);
+  WINLOG_IFALL(
+      WINDOWS_LOG_PROCESS,
+      "StopDebugging waiting for detach from process %llu to complete.", pid);
 
   DWORD wait_result = WaitForSingleObject(m_debugging_ended_event, 5000);
   if (wait_result != WAIT_OBJECT_0) {
     error.SetError(GetLastError(), eErrorTypeWin32);
     WINERR_IFALL(WINDOWS_LOG_PROCESS,
-                 "StopDebugging WaitForSingleObject(0x%p, 5000) returned %u",
+                 "StopDebugging WaitForSingleObject(0x%p, 5000) returned %lu",
                  m_debugging_ended_event, wait_result);
   } else {
-    WINLOG_IFALL(WINDOWS_LOG_PROCESS,
-                 "StopDebugging detach from process %u completed successfully.",
-                 pid);
+    WINLOG_IFALL(
+        WINDOWS_LOG_PROCESS,
+        "StopDebugging detach from process %llu completed successfully.", pid);
   }
 
   if (!error.Success()) {
     WINERR_IFALL(WINDOWS_LOG_PROCESS, "StopDebugging encountered an error "
-                                      "while trying to stop process %u.  %s",
+                                      "while trying to stop process %llu.  %s",
                  pid, error.AsCString());
   }
   return error;
 }
 
 void DebuggerThread::ContinueAsyncException(ExceptionResult result) {
   if (!m_active_exception.get())
     return;
void DebuggerThread::FreeProcessHandles() {
   m_main_thread = HostThread();
   if (m_image_file) {
     ::CloseHandle(m_image_file);
     m_image_file = nullptr;
   }
 }
 
 void DebuggerThread::DebugLoop() {
-  DEBUG_EVENT dbe = {0};
+  DEBUG_EVENT dbe = {};
   bool should_debug = true;
   WINLOG_IFALL(WINDOWS_LOG_EVENT, "Entering WaitForDebugEvent loop");
   while (should_debug) {
     WINLOGD_IFALL(WINDOWS_LOG_EVENT, "Calling WaitForDebugEvent");
     BOOL wait_result = WaitForDebugEvent(&dbe, INFINITE);
     if (wait_result) {
       DWORD continue_status = DBG_CONTINUE;
       switch (dbe.dwDebugEventCode) {
if (wait_result) {
         continue_status = HandleRipEvent(dbe.u.RipInfo, dbe.dwThreadId);
         if (dbe.u.RipInfo.dwType == SLE_ERROR)
           should_debug = false;
         break;
       }
 
       WINLOGD_IFALL(
           WINDOWS_LOG_EVENT,
-          "DebugLoop calling ContinueDebugEvent(%u, %u, %u) on thread %u.",
+          "DebugLoop calling ContinueDebugEvent(%lu, %lu, %lu) on thread %lu.",
           dbe.dwProcessId, dbe.dwThreadId, continue_status,
           ::GetCurrentThreadId());
 
       ::ContinueDebugEvent(dbe.dwProcessId, dbe.dwThreadId, continue_status);
 
       if (m_detached) {
         should_debug = false;
       }
     } else {
       WINERR_IFALL(
           WINDOWS_LOG_EVENT,
-          "DebugLoop returned FALSE from WaitForDebugEvent.  Error = %u",
-          ::GetCurrentThreadId(), ::GetLastError());
+          "DebugLoop returned FALSE from WaitForDebugEvent.  Error = %lu",
+          ::GetLastError());
 
       should_debug = false;
     }
   }
   FreeProcessHandles();
 
   WINLOG_IFALL(WINDOWS_LOG_EVENT, "WaitForDebugEvent loop completed, exiting.");
   SetEvent(m_debugging_ended_event);
 }
 
 ExceptionResult
 DebuggerThread::HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
                                      DWORD thread_id) {
   if (m_is_shutting_down) {
     // A breakpoint that occurs while `m_pid_to_detach` is non-zero is a magic
     // exception that
     // we use simply to wake up the DebuggerThread so that we can close out the
     // debug loop.
     if (m_pid_to_detach != 0 &&
         info.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT) {
       WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION |
                        WINDOWS_LOG_PROCESS,
-                   "Breakpoint exception is cue to detach from process 0x%x",
+                   "Breakpoint exception is cue to detach from process 0x%lx",
                    m_pid_to_detach.load());
       ::DebugActiveProcessStop(m_pid_to_detach);
       m_detached = true;
     }
 
     // Don't perform any blocking operations while we're shutting down.  That
     // will
     // cause TerminateProcess -> WaitForSingleObject to time out.
     return ExceptionResult::SendToApplication;
   }
 
   bool first_chance = (info.dwFirstChance != 0);
 
   m_active_exception.reset(
       new ExceptionRecord(info.ExceptionRecord, thread_id));
   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION,
-               "HandleExceptionEvent encountered %s chance exception 0x%x on "
-               "thread 0x%x",
+               "HandleExceptionEvent encountered %s chance exception 0x%lx on "
+               "thread 0x%lx",
                first_chance ? "first" : "second",
                info.ExceptionRecord.ExceptionCode, thread_id);
 
   ExceptionResult result =
       m_debug_delegate->OnDebugException(first_chance, *m_active_exception);
   m_exception_pred.SetValue(result, eBroadcastNever);
 
   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_EXCEPTION,
DebuggerThread::HandleExceptionEvent(const EXCEPTION_DEBUG_INFO &info,
 
   return result;
 }
 
 DWORD
 DebuggerThread::HandleCreateThreadEvent(const CREATE_THREAD_DEBUG_INFO &info,
                                         DWORD thread_id) {
   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD,
-               "HandleCreateThreadEvent Thread 0x%x spawned in process %I64u",
+               "HandleCreateThreadEvent Thread 0x%lx spawned in process %llu",
                thread_id, m_process.GetProcessId());
   HostThread thread(info.hThread);
   thread.GetNativeThread().SetOwnsHandle(false);
   m_debug_delegate->OnCreateThread(thread);
   return DBG_CONTINUE;
 }
 
 DWORD
DebuggerThread::HandleCreateProcessEvent(const CREATE_PROCESS_DEBUG_INFO &info,
   return DBG_CONTINUE;
 }
 
 DWORD
 DebuggerThread::HandleExitThreadEvent(const EXIT_THREAD_DEBUG_INFO &info,
                                       DWORD thread_id) {
   WINLOG_IFANY(
       WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD,
-      "HandleExitThreadEvent Thread %u exited with code %u in process %I64u",
+      "HandleExitThreadEvent Thread %lu exited with code %lu in process %llu",
       thread_id, info.dwExitCode, m_process.GetProcessId());
   m_debug_delegate->OnExitThread(thread_id, info.dwExitCode);
   return DBG_CONTINUE;
 }
 
 DWORD
 DebuggerThread::HandleExitProcessEvent(const EXIT_PROCESS_DEBUG_INFO &info,
                                        DWORD thread_id) {
   WINLOG_IFANY(WINDOWS_LOG_EVENT | WINDOWS_LOG_THREAD,
-               "HandleExitProcessEvent process %I64u exited with code %u",
+               "HandleExitProcessEvent process %llu exited with code %lu",
                m_process.GetProcessId(), info.dwExitCode);
 
   m_debug_delegate->OnExitProcess(info.dwExitCode);
 
   FreeProcessHandles();
   return DBG_CONTINUE;
 }
 
 DWORD
 DebuggerThread::HandleLoadDllEvent(const LOAD_DLL_DEBUG_INFO &info,
                                    DWORD thread_id) {
   if (info.hFile == nullptr) {
     // Not sure what this is, so just ignore it.
-    WINWARN_IFALL(WINDOWS_LOG_EVENT, "Inferior %I64u - HandleLoadDllEvent has "
+    WINWARN_IFALL(WINDOWS_LOG_EVENT, "Inferior %llu - HandleLoadDllEvent has "
                                      "a NULL file handle, returning...",
                   m_process.GetProcessId());
     return DBG_CONTINUE;
   }
 
   std::vector<wchar_t> buffer(1);
   DWORD required_size =
       GetFinalPathNameByHandleW(info.hFile, &buffer[0], 0, VOLUME_NAME_DOS);
if (required_size > 0) {
     lldb::addr_t load_addr = reinterpret_cast<lldb::addr_t>(info.lpBaseOfDll);
 
     WINLOG_IFALL(WINDOWS_LOG_EVENT, "Inferior %I64u - HandleLoadDllEvent DLL "
                                     "'%s' loaded at address 0x%p...",
                  m_process.GetProcessId(), path, info.lpBaseOfDll);
 
     m_debug_delegate->OnLoadDll(module_spec, load_addr);
   } else {
-    WINERR_IFALL(WINDOWS_LOG_EVENT, "Inferior %I64u - HandleLoadDllEvent Error "
-                                    "%u occurred calling "
+    WINERR_IFALL(WINDOWS_LOG_EVENT, "Inferior %llu - HandleLoadDllEvent Error "
+                                    "%lu occurred calling "
                                     "GetFinalPathNameByHandle",
                  m_process.GetProcessId(), ::GetLastError());
   }
   // Windows does not automatically close info.hFile, so we need to do it.
   ::CloseHandle(info.hFile);
   return DBG_CONTINUE;
 }
 
 DWORD
 DebuggerThread::HandleUnloadDllEvent(const UNLOAD_DLL_DEBUG_INFO &info,
                                      DWORD thread_id) {
   WINLOG_IFALL(WINDOWS_LOG_EVENT,
-               "HandleUnloadDllEvent process %I64u unloading DLL at addr 0x%p.",
+               "HandleUnloadDllEvent process %llu unloading DLL at addr 0x%p.",
                m_process.GetProcessId(), info.lpBaseOfDll);
 
   m_debug_delegate->OnUnloadDll(
       reinterpret_cast<lldb::addr_t>(info.lpBaseOfDll));
   return DBG_CONTINUE;
 }
 
 DWORD
 DebuggerThread::HandleODSEvent(const OUTPUT_DEBUG_STRING_INFO &info,
                                DWORD thread_id) {
   return DBG_CONTINUE;
 }
 
 DWORD
 DebuggerThread::HandleRipEvent(const RIP_INFO &info, DWORD thread_id) {
-  WINERR_IFALL(WINDOWS_LOG_EVENT, "HandleRipEvent encountered error %u "
-                                  "(type=%u) in process %I64u thread %u",
+  WINERR_IFALL(WINDOWS_LOG_EVENT, "HandleRipEvent encountered error %lu "
+                                  "(type=%lu) in process %llu thread %lu",
                info.dwError, info.dwType, m_process.GetProcessId(), thread_id);
 
   Error error(info.dwError, eErrorTypeWin32);
   m_debug_delegate->OnDebuggerError(error, info.dwType);
 
   return DBG_CONTINUE;
 }

source/Plugins/Process/Windows/Live/ProcessWindowsLive.h

 #include "IDebugDelegate.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Target/Process.h"
 #include "lldb/lldb-forward.h"
 
 #include "llvm/Support/Mutex.h"
 
-#include "plugins/Process/Windows/Common/ProcessWindows.h"
+#include "Plugins/Process/Windows/Common/ProcessWindows.h"
 
 class ProcessMonitor;
 
 namespace lldb_private {
 class HostProcess;
 class ProcessWindowsData;
 
 class ProcessWindowsLive : public lldb_private::ProcessWindows,

source/Plugins/Process/Windows/Live/ProcessWindowsLive.cpp

 
 namespace lldb_private {
 
 // We store a pointer to this class in the ProcessWindows, so that we don't
 // expose Windows
 // OS specific types and implementation details from a public header file.
 class ProcessWindowsData {
 public:
-  ProcessWindowsData(bool stop_at_entry)
-      : m_stop_at_entry(stop_at_entry), m_initial_stop_event(nullptr),
-        m_initial_stop_received(false) {
+  ProcessWindowsData(bool stop_at_entry) : m_stop_at_entry(stop_at_entry) {
     m_initial_stop_event = ::CreateEvent(nullptr, TRUE, FALSE, nullptr);
   }
 
   ~ProcessWindowsData() { ::CloseHandle(m_initial_stop_event); }
 
   lldb_private::Error m_launch_error;
   lldb_private::DebuggerThreadSP m_debugger;
   StopInfoSP m_pending_stop_info;
-  HANDLE m_initial_stop_event;
+  HANDLE m_initial_stop_event = nullptr;
+  bool m_initial_stop_received = false;
   bool m_stop_at_entry;
-  bool m_initial_stop_received;
   std::map<lldb::tid_t, HostThread> m_new_threads;
   std::set<lldb::tid_t> m_exited_threads;
 };
 }
 //------------------------------------------------------------------------------
 // Static functions.
 
 ProcessSP ProcessWindowsLive::CreateInstance(lldb::TargetSP target_sp,

 
 const char *ProcessWindowsLive::GetPluginDescriptionStatic() {
   return "Process plugin for Windows";
 }
 
 Error ProcessWindowsLive::EnableBreakpointSite(BreakpointSite *bp_site) {
   WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS,
                "EnableBreakpointSite called with bp_site 0x%p "
-               "(id=%d, addr=0x%x)",
-               bp_site->GetID(), bp_site->GetLoadAddress());
+               "(id=%d, addr=0x%llx)",
+               bp_site, bp_site->GetID(), bp_site->GetLoadAddress());
 
   Error error = EnableSoftwareBreakpoint(bp_site);
   if (!error.Success()) {
     WINERR_IFALL(WINDOWS_LOG_BREAKPOINTS, "EnableBreakpointSite failed.  %s",
                  error.AsCString());
   }
   return error;
 }
 
 Error ProcessWindowsLive::DisableBreakpointSite(BreakpointSite *bp_site) {
   WINLOG_IFALL(WINDOWS_LOG_BREAKPOINTS,
                "DisableBreakpointSite called with bp_site 0x%p "
-               "(id=%d, addr=0x%x)",
+               "(id=%d, addr=0x%llx)",
                bp_site, bp_site->GetID(), bp_site->GetLoadAddress());
 
   Error error = DisableSoftwareBreakpoint(bp_site);
 
   if (!error.Success()) {
     WINERR_IFALL(WINDOWS_LOG_BREAKPOINTS, "DisableBreakpointSite failed.  %s",
                  error.AsCString());
   }
for (ThreadSP old_thread : old_thread_list.Threads()) {
     auto exited_thread_iter =
         m_session_data->m_exited_threads.find(old_thread_id);
     if (exited_thread_iter == m_session_data->m_exited_threads.end()) {
       new_thread_list.AddThread(old_thread);
       ++new_size;
       ++continued_threads;
       WINLOGV_IFALL(
           WINDOWS_LOG_THREAD,
-          "UpdateThreadList - Thread %u was running and is still running.",
+          "UpdateThreadList - Thread %llu was running and is still running.",
           old_thread_id);
     } else {
-      WINLOGV_IFALL(WINDOWS_LOG_THREAD,
-                    "UpdateThreadList - Thread %u was running and has exited.",
-                    old_thread_id);
+      WINLOGV_IFALL(
+          WINDOWS_LOG_THREAD,
+          "UpdateThreadList - Thread %llu was running and has exited.",
       ++exited_threads;
     }
   }
 
   // Also add all the threads that are new since the last time we broke into the
   // debugger.
   for (const auto &thread_info : m_session_data->m_new_threads) {
     ThreadSP thread(new TargetThreadWindowsLive(*this, thread_info.second));
     thread->SetID(thread_info.first);
     new_thread_list.AddThread(thread);
     ++new_size;
     ++new_threads;
     WINLOGV_IFALL(WINDOWS_LOG_THREAD,
-                  "UpdateThreadList - Thread %u is new since last update.",
+                  "UpdateThreadList - Thread %llu is new since last update.",
                   thread_info.first);
   }
 
   WINLOG_IFALL(
       WINDOWS_LOG_THREAD,
       "UpdateThreadList - %d new threads, %d old threads, %d exited threads.",
       new_threads, continued_threads, exited_threads);
 
Error ProcessWindowsLive::DoLaunch(Module *exe_module,
   if (!launch_info.GetFlags().Test(eLaunchFlagDebug)) {
     StreamString stream;
     stream.Printf("ProcessWindows unable to launch '%s'.  ProcessWindows can "
                   "only be used for debug launches.",
                   launch_info.GetExecutableFile().GetPath().c_str());
     std::string message = stream.GetString();
     result.SetErrorString(message.c_str());
 
-    WINERR_IFALL(WINDOWS_LOG_PROCESS, message.c_str());
+    WINERR_IFALL(WINDOWS_LOG_PROCESS, "%s", message.c_str());
     return result;
   }
 
   bool stop_at_entry = launch_info.GetFlags().Test(eLaunchFlagStopAtEntry);
   m_session_data.reset(new ProcessWindowsData(stop_at_entry));
 
   SetPrivateState(eStateLaunching);
   DebugDelegateSP delegate(new LocalDebugDelegate(shared_from_this()));
WINLOG_IFALL(WINDOWS_LOG_PROCESS, "DoAttachToProcessWithID encountered an "
                                       "error waiting for the debugger to "
                                       "connect.  %s",
                  error.AsCString());
     return error;
   }
 
   WINLOG_IFALL(
       WINDOWS_LOG_PROCESS,
-      "DoAttachToProcessWithID successfully attached to process with pid=%u",
+      "DoAttachToProcessWithID successfully attached to process with pid=%lu",
       process_id);
 
   // We've hit the initial stop.  If eLaunchFlagsStopAtEntry was specified, the
   // private state
   // should already be set to eStateStopped as a result of hitting the initial
   // breakpoint.  If
   // it was not set, the breakpoint should have already been resumed from and
   // the private state
if (active_exception) {
       // indication that anything happened.
       m_session_data->m_debugger->ContinueAsyncException(
           ExceptionResult::MaskException);
     }
 
     WINLOG_IFANY(WINDOWS_LOG_PROCESS | WINDOWS_LOG_THREAD,
                  "DoResume resuming %u threads.", m_thread_list.GetSize());
 
-    for (int i = 0; i < m_thread_list.GetSize(); ++i) {
+    for (uint32_t i = 0; i < m_thread_list.GetSize(); ++i) {
       auto thread = std::static_pointer_cast<TargetThreadWindowsLive>(
           m_thread_list.GetThreadAtIndex(i));
       thread->DoResume();
     }
 
     SetPrivateState(eStateRunning);
   } else {
     WINERR_IFALL(
StateType private_state;
 
     debugger_thread = m_session_data->m_debugger;
   }
 
   Error error;
   if (private_state != eStateExited && private_state != eStateDetached) {
     WINLOG_IFALL(
         WINDOWS_LOG_PROCESS,
-        "DoDetach called for process %I64u while state = %u.  Detaching...",
+        "DoDetach called for process %p while state = %d.  Detaching...",
         debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(),
         private_state);
     error = debugger_thread->StopDebugging(false);
     if (error.Success()) {
       SetPrivateState(eStateDetached);
     }
 
     // By the time StopDebugging returns, there is no more debugger thread, so
     // we can be assured that no other thread will race for the session data.
     m_session_data.reset();
   } else {
     WINERR_IFALL(
-        WINDOWS_LOG_PROCESS, "DoDetach called for process %I64u while state = "
-                             "%u, but cannot destroy in this state.",
+        WINDOWS_LOG_PROCESS, "DoDetach called for process %p while state = "
+                             "%d, but cannot destroy in this state.",
         debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(),
         private_state);
   }
 
   return error;
 }
 
 Error ProcessWindowsLive::DoDestroy() {
StateType private_state;
     }
 
     debugger_thread = m_session_data->m_debugger;
   }
 
   Error error;
   if (private_state != eStateExited && private_state != eStateDetached) {
     WINLOG_IFALL(
-        WINDOWS_LOG_PROCESS, "DoDestroy called for process %I64u while state = "
+        WINDOWS_LOG_PROCESS, "DoDestroy called for process %p while state = "
                              "%u.  Shutting down...",
         debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(),
         private_state);
     error = debugger_thread->StopDebugging(true);
 
     // By the time StopDebugging returns, there is no more debugger thread, so
     // we can be assured that no other thread will race for the session data.
     m_session_data.reset();
   } else {
     WINERR_IFALL(
-        WINDOWS_LOG_PROCESS, "DoDestroy called for process %I64u while state = "
-                             "%u, but cannot destroy in this state.",
+        WINDOWS_LOG_PROCESS, "DoDestroy called for process %p while state = "
+                             "%d, but cannot destroy in this state.",
         debugger_thread->GetProcess().GetNativeProcess().GetSystemHandle(),
         private_state);
   }
 
   return error;
 }
 
 void ProcessWindowsLive::RefreshStateAfterStop() {
if (site && site->ValidForThisThread(stop_thread.get())) {
                    "address 0x%I64x with breakpoint site %d",
                    m_session_data->m_debugger->GetProcess().GetProcessId(), pc,
                    site->GetID());
       stop_info = StopInfo::CreateStopReasonWithBreakpointSiteID(*stop_thread,
                                                                  site->GetID());
       stop_thread->SetStopInfo(stop_info);
     } else {
       WINLOG_IFANY(WINDOWS_LOG_EXCEPTION | WINDOWS_LOG_STEP,
-                   "RefreshStateAfterStop single stepping thread %u",
+                   "RefreshStateAfterStop single stepping thread %llu",
                    stop_thread->GetID());
       stop_info = StopInfo::CreateStopReasonToTrace(*stop_thread);
       stop_thread->SetStopInfo(stop_info);
     }
     return;
   }
 
   case EXCEPTION_BREAKPOINT: {
default: {
     llvm::raw_string_ostream desc_stream(desc);
     desc_stream << "Exception "
                 << llvm::format_hex(active_exception->GetExceptionCode(), 8)
                 << " encountered at address "
                 << llvm::format_hex(active_exception->GetExceptionAddress(), 8);
     stop_info = StopInfo::CreateStopReasonWithException(
         *stop_thread, desc_stream.str().c_str());
     stop_thread->SetStopInfo(stop_info);
-    WINLOG_IFALL(WINDOWS_LOG_EXCEPTION, desc_stream.str().c_str());
+    WINLOG_IFALL(WINDOWS_LOG_EXCEPTION, "%s", desc_stream.str().c_str());
     return;
   }
   }
 }
 
 bool ProcessWindowsLive::IsAlive() {
   StateType state = GetPrivateState();
   switch (state) {
Error ProcessWindowsLive::GetMemoryRegionInfo(lldb::addr_t vm_addr,
                                               MemoryRegionInfo &info) {
   Error error;
   llvm::sys::ScopedLock lock(m_mutex);
   info.Clear();
 
   if (!m_session_data) {
     error.SetErrorString(
         "GetMemoryRegionInfo called with no debugging session.");
-    WINERR_IFALL(WINDOWS_LOG_MEMORY, error.AsCString());
+    WINERR_IFALL(WINDOWS_LOG_MEMORY, "%s", error.AsCString());
     return error;
   }
   HostProcess process = m_session_data->m_debugger->GetProcess();
   lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
   if (handle == nullptr || handle == LLDB_INVALID_PROCESS) {
     error.SetErrorString(
         "GetMemoryRegionInfo called with an invalid target process.");
-    WINERR_IFALL(WINDOWS_LOG_MEMORY, error.AsCString());
+    WINERR_IFALL(WINDOWS_LOG_MEMORY, "%s", error.AsCString());
     return error;
   }
 
   WINLOG_IFALL(WINDOWS_LOG_MEMORY,
                "GetMemoryRegionInfo getting info for address 0x%I64x", vm_addr);
 
   void *addr = reinterpret_cast<void *>(vm_addr);
-  MEMORY_BASIC_INFORMATION mem_info = {0};
+  MEMORY_BASIC_INFORMATION mem_info = {};
   SIZE_T result = ::VirtualQueryEx(handle, addr, &mem_info, sizeof(mem_info));
   if (result == 0) {
     if (::GetLastError() == ERROR_INVALID_PARAMETER) {
       // ERROR_INVALID_PARAMETER is returned if VirtualQueryEx is called with an
       // address
       // past the highest accessible address. We should return a range from the
       // vm_addr
       // to LLDB_INVALID_ADDRESS
if (mem_info.State != MEM_FREE) {
     GetSystemInfo(&data);
     DWORD page_offset = vm_addr % data.dwPageSize;
     info.GetRange().SetRangeBase(vm_addr);
     info.GetRange().SetByteSize(mem_info.RegionSize - page_offset);
     info.SetMapped(MemoryRegionInfo::eNo);
   }
 
   error.SetError(::GetLastError(), eErrorTypeWin32);
-  WINLOGV_IFALL(WINDOWS_LOG_MEMORY, "Memory region info for address 0x%I64u: "
+  WINLOGV_IFALL(WINDOWS_LOG_MEMORY, "Memory region info for address %llu: "
                                     "readable=%s, executable=%s, writable=%s",
-                BOOL_STR(info.GetReadable()), BOOL_STR(info.GetExecutable()),
-                BOOL_STR(info.GetWritable()));
+                vm_addr, BOOL_STR(info.GetReadable()),
+                BOOL_STR(info.GetExecutable()), BOOL_STR(info.GetWritable()));
   return error;
 }
 
 bool ProcessWindowsLive::CanDebug(lldb::TargetSP target_sp,
                                   bool plugin_specified_by_name) {
   if (plugin_specified_by_name)
     return true;
 
   // For now we are just making sure the file exists for a given module
   ModuleSP exe_module_sp(target_sp->GetExecutableModule());
   if (exe_module_sp.get())
     return exe_module_sp->GetFileSpec().Exists();
   // However, if there is no executable module, we return true since we might be
   // preparing to attach.
   return true;
 }
 
 void ProcessWindowsLive::OnExitProcess(uint32_t exit_code) {
   // No need to acquire the lock since m_session_data isn't accessed.
-  WINLOG_IFALL(WINDOWS_LOG_PROCESS, "Process %u exited with code %u", GetID(),
+  WINLOG_IFALL(WINDOWS_LOG_PROCESS, "Process %llu exited with code %u", GetID(),
                exit_code);
 
   TargetSP target = m_target_sp.lock();
   if (target) {
     ModuleSP executable_module = target->GetExecutableModule();
     ModuleList unloaded_modules;
     unloaded_modules.Append(executable_module);
     target->ModulesDidUnload(unloaded_modules, true);
ProcessWindowsLive::OnDebugException(bool first_chance,
   // happen
   // but it only surfaces while running the test suite.  In order to properly
   // diagnose
   // this, we probably need to first figure allow the test suite to print out
   // full
   // lldb logs, and then add logging to the process plugin.
   if (!m_session_data) {
     WINERR_IFANY(WINDOWS_LOG_EXCEPTION, "Debugger thread reported exception "
-                                        "0x%x at address 0x%I64x, but there is "
+                                        "0x%lx at address 0x%llu, but there is "
                                         "no session.",
                  record.GetExceptionCode(), record.GetExceptionAddress());
     return ExceptionResult::SendToApplication;
   }
 
   if (!first_chance) {
     // Any second chance exception is an application crash by definition.
     SetPrivateState(eStateCrashed);
case EXCEPTION_BREAKPOINT:
     SetPrivateState(eStateStopped);
     break;
   case EXCEPTION_SINGLE_STEP:
     result = ExceptionResult::BreakInDebugger;
     SetPrivateState(eStateStopped);
     break;
   default:
     WINLOG_IFANY(WINDOWS_LOG_EXCEPTION, "Debugger thread reported exception "
-                                        "0x%x at address 0x%I64x "
+                                        "0x%lx at address 0x%llx "
                                         "(first_chance=%s)",
                  record.GetExceptionCode(), record.GetExceptionAddress(),
                  BOOL_STR(first_chance));
     // For non-breakpoints, give the application a chance to handle the
     // exception first.
     if (first_chance)
       result = ExceptionResult::SendToApplication;
     else

source/Plugins/Process/Windows/MiniDump/ProcessWinMiniDump.cpp

for (ULONG32 i = 0; i < thread_count; ++i) {
           *m_self, mini_dump_thread.ThreadId);
       if (mini_dump_thread.ThreadContext.DataSize >= sizeof(CONTEXT)) {
         const CONTEXT *context = reinterpret_cast<const CONTEXT *>(
             static_cast<const char *>(m_base_addr) +
             mini_dump_thread.ThreadContext.Rva);
 
         if (m_is_wow64) {
           // On Windows, a 32-bit process can run on a 64-bit machine under
-          // WOW64.
-          // If the minidump was captured with a 64-bit debugger, then the
-          // CONTEXT
-          // we just grabbed from the mini_dump_thread is the one for the 64-bit
-          // "native" process rather than the 32-bit "guest" process we care
-          // about.
-          // In this case, we can get the 32-bit CONTEXT from the TEB (Thread
-          // Environment Block) of the 64-bit process.
+          // WOW64. If the minidump was captured with a 64-bit debugger, then
+          // the CONTEXT we just grabbed from the mini_dump_thread is the one
+          // for the 64-bit "native" process rather than the 32-bit "guest"
+          // process we care about.  In this case, we can get the 32-bit CONTEXT
+          // from the TEB (Thread Environment Block) of the 64-bit process.
           Error error;
-          TEB64 wow64teb = {0};
+          TEB64 wow64teb = {};
           m_self->ReadMemory(mini_dump_thread.Teb, &wow64teb, sizeof(wow64teb),
                              error);
           if (error.Success()) {
             // Slot 1 of the thread-local storage in the 64-bit TEB points to a
-            // structure
-            // that includes the 32-bit CONTEXT (after a ULONG).
+            // structure that includes the 32-bit CONTEXT (after a ULONG).
             // See:  https://msdn.microsoft.com/en-us/library/ms681670.aspx
-            const size_t addr = wow64teb.TlsSlots[1];
-            Range range = {0};
+            const lldb::addr_t addr = wow64teb.TlsSlots[1];
+            Range range = {};
             if (FindMemoryRange(addr, &range)) {
               lldbassert(range.start <= addr);
               const size_t offset = addr - range.start + sizeof(ULONG);
               if (offset < range.size) {
                 const size_t overlap = range.size - offset;
                 if (overlap >= sizeof(CONTEXT)) {
                   context =
                       reinterpret_cast<const CONTEXT *>(range.ptr + offset);

 }
 
 size_t ProcessWinMiniDump::Impl::DoReadMemory(lldb::addr_t addr, void *buf,
                                               size_t size, Error &error) {
   // I don't have a sense of how frequently this is called or how many memory
   // ranges a mini dump typically has, so I'm not sure if searching for the
   // appropriate range linearly each time is stupid.  Perhaps we should build
   // an index for faster lookups.
-  Range range = {0};
+  Range range = {};
   if (!FindMemoryRange(addr, &range)) {
     return 0;
   }
 
   // There's at least some overlap between the beginning of the desired range
   // (addr) and the current range.  Figure out where the overlap begins and
   // how much overlap there is, then copy it to the destination buffer.
   lldbassert(range.start <= addr);
Error ProcessWinMiniDump::Impl::GetMemoryRegionInfo(
 
   if (size < list->SizeOfHeader + list->SizeOfEntry * list->NumberOfEntries) {
     error.SetErrorString("the mini dump memory info list is incomplete");
     return error;
   }
 
   const MINIDUMP_MEMORY_INFO *next_entry = nullptr;
 
-  for (int i = 0; i < list->NumberOfEntries; ++i) {
+  for (uint64_t i = 0; i < list->NumberOfEntries; ++i) {
     const auto entry = reinterpret_cast<const MINIDUMP_MEMORY_INFO *>(
         reinterpret_cast<const char *>(list) + list->SizeOfHeader +
         i * list->SizeOfEntry);
     const auto head = entry->BaseAddress;
     const auto tail = head + entry->RegionSize;
     if (head <= load_addr && load_addr < tail) {
       info.GetRange().SetRangeBase((entry->State != MEM_FREE) ? head
                                                               : load_addr);

source/Plugins/Process/elf-core/ThreadElfCore.cpp

ELFLinuxPrStatus::ELFLinuxPrStatus() {
   memset(this, 0, sizeof(ELFLinuxPrStatus));
 }
 
 Error ELFLinuxPrStatus::Parse(DataExtractor &data, ArchSpec &arch) {
   Error error;
   ByteOrder byteorder = data.GetByteOrder();
   if (GetSize(arch) > data.GetByteSize()) {
     error.SetErrorStringWithFormat(
-        "NT_PRSTATUS size should be %lu, but the remaining bytes are: %" PRIu64,
+        "NT_PRSTATUS size should be %zu, but the remaining bytes are: %" PRIu64,
         GetSize(arch), data.GetByteSize());
     return error;
   }
 
   switch (arch.GetCore()) {
   case ArchSpec::eCore_s390x_generic:
   case ArchSpec::eCore_x86_64_x86_64:
     data.ExtractBytes(0, sizeof(ELFLinuxPrStatus), byteorder, this);
ELFLinuxPrPsInfo::ELFLinuxPrPsInfo() {
   memset(this, 0, sizeof(ELFLinuxPrPsInfo));
 }
 
 Error ELFLinuxPrPsInfo::Parse(DataExtractor &data, ArchSpec &arch) {
   Error error;
   ByteOrder byteorder = data.GetByteOrder();
   if (GetSize(arch) > data.GetByteSize()) {
     error.SetErrorStringWithFormat(
-        "NT_PRPSINFO size should be %lu, but the remaining bytes are: %" PRIu64,
+        "NT_PRPSINFO size should be %zu, but the remaining bytes are: %" PRIu64,
         GetSize(arch), data.GetByteSize());
     return error;
   }
 
   switch (arch.GetCore()) {
   case ArchSpec::eCore_s390x_generic:
   case ArchSpec::eCore_x86_64_x86_64:
     data.ExtractBytes(0, sizeof(ELFLinuxPrPsInfo), byteorder, this);

source/Plugins/ScriptInterpreter/Python/lldb-python.h

 // redefinition of macros
 
 #ifdef LLDB_DISABLE_PYTHON
 // Python is disabled in this build
 #else
 #include "llvm/Support/Compiler.h"
 #if defined(LLVM_ON_WIN32)
 // If anyone #includes Host/PosixApi.h later, it will try to typedef pid_t.  We
-// need to ensure
-// this doesn't happen.
+// need to ensure this doesn't happen.  At the same time, Python.h will also try
+// to redefine a bunch of stuff that PosixApi.h defines.  So define it all now
+// so that PosixApi.h doesn't redefine it.
 #define NO_PID_T
 #endif
 #if defined(__linux__)
 // features.h will define _POSIX_C_SOURCE if _GNU_SOURCE is defined.  This value
 // may be different from the value that Python defines it to be which results
 // in a warning.  Undefine _POSIX_C_SOURCE before including Python.h  The same
 // holds for _XOPEN_SOURCE.
 #undef _POSIX_C_SOURCE
 #undef _XOPEN_SOURCE
 #endif
 
 // Include python for non windows machines
 #include <Python.h>
 #endif // LLDB_DISABLE_PYTHON
 
 #endif // LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_LLDB_PYTHON_H

source/Symbol/ClangASTContext.cpp

ClangASTContext::GetTypeClass(lldb::opaque_compiler_type_t type) {
   case clang::Type::Pipe:
     break;
 
   // pointer type decayed from an array or function type.
   case clang::Type::Decayed:
     break;
   case clang::Type::Adjusted:
     break;
+  case clang::Type::ObjCTypeParam:
+    break;
   }
   // We don't know hot to display this type...
   return lldb::eTypeClassOther;
 }
 
 unsigned ClangASTContext::GetTypeQualifiers(lldb::opaque_compiler_type_t type) {
   if (type)
     return GetQualType(type).getQualifiers().getCVRQualifiers();
lldb::Encoding ClangASTContext::GetEncoding(lldb::opaque_compiler_type_t type,
   case clang::Type::Atomic:
   case clang::Type::Adjusted:
   case clang::Type::Pipe:
     break;
 
   // pointer type decayed from an array or function type.
   case clang::Type::Decayed:
     break;
+  case clang::Type::ObjCTypeParam:
+    break;
   }
   count = 0;
   return lldb::eEncodingInvalid;
 }
 
 lldb::Format ClangASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
   if (!type)
     return lldb::eFormatDefault;
lldb::Format ClangASTContext::GetFormat(lldb::opaque_compiler_type_t type) {
   case clang::Type::Atomic:
   case clang::Type::Adjusted:
   case clang::Type::Pipe:
     break;
 
   // pointer type decayed from an array or function type.
   case clang::Type::Decayed:
     break;
+  case clang::Type::ObjCTypeParam:
+    break;
   }
   // We don't know hot to display this type...
   return lldb::eFormatBytes;
 }
 
 static bool ObjCDeclHasIVars(clang::ObjCInterfaceDecl *class_interface_decl,
                              bool check_superclass) {
   while (class_interface_decl) {

source/Symbol/OCamlASTContext.cpp

bool OCamlASTContext::DumpTypeValue(
     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
     ExecutionContextScope *exe_scope) {
   if (!type) {
     s->Printf("no type value\n");
     return false;
   }
 
   if (IsScalarType(type)) {
-    return data.Dump(s, byte_offset, format, byte_size, 1, UINT64_MAX,
+    return data.Dump(s, byte_offset, format, byte_size, 1, SIZE_MAX,
                      LLDB_INVALID_ADDRESS, bitfield_bit_size,
                      bitfield_bit_offset, exe_scope);
   }
 
   return false;
 }
 
 void OCamlASTContext::DumpSummary(lldb::opaque_compiler_type_t type,

source/Target/Memory.cpp

if (m_offset_to_chunk_size.empty()) {
           const uint32_t bytes_available = pos->first - last_offset;
           const uint32_t num_chunks =
               CalculateChunksNeededForSize(bytes_available);
           if (num_chunks >= needed_chunks) {
             m_offset_to_chunk_size[last_offset] = needed_chunks;
             if (log)
               log->Printf("[2] AllocatedBlock::ReserveBlock(%p) (size = %u "
                           "(0x%x)) => offset = 0x%x, %u %u bit chunks - "
-                          "num_chunks %lu",
+                          "num_chunks %zu",
                           (void *)this, size, size, last_offset, needed_chunks,
                           m_chunk_size, m_offset_to_chunk_size.size());
             addr = m_addr + last_offset;
             break;
           }
         }
 
         last_offset = pos->first + pos->second * m_chunk_size;
 
         if (++pos == end) {
           // Last entry...
           const uint32_t chunks_left =
               CalculateChunksNeededForSize(m_byte_size - last_offset);
           if (chunks_left >= needed_chunks) {
             m_offset_to_chunk_size[last_offset] = needed_chunks;
             if (log)
               log->Printf("[3] AllocatedBlock::ReserveBlock(%p) (size = %u "
                           "(0x%x)) => offset = 0x%x, %u %u bit chunks - "
-                          "num_chunks %lu",
+                          "num_chunks %zu",
                           (void *)this, size, size, last_offset, needed_chunks,
                           m_chunk_size, m_offset_to_chunk_size.size());
             addr = m_addr + last_offset;
             break;
           }
         }
       }
     }
bool AllocatedBlock::FreeBlock(addr_t addr) {
   bool success = false;
   if (pos != m_offset_to_chunk_size.end()) {
     m_offset_to_chunk_size.erase(pos);
     success = true;
   }
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_VERBOSE));
   if (log)
     log->Printf("AllocatedBlock::FreeBlock(%p) (addr = 0x%16.16" PRIx64
-                ") => %i, num_chunks: %lu",
+                ") => %i, num_chunks: %zu",
                 (void *)this, (uint64_t)addr, success,
                 m_offset_to_chunk_size.size());
   return success;
 }
 
 AllocatedMemoryCache::AllocatedMemoryCache(Process &process)
     : m_process(process), m_mutex(), m_memory_map() {}
 

source/Utility/SelectHelper.cpp

: m_fd_map(), m_end_time() // Infinite timeout unless
                                // SelectHelper::SetTimeout() gets called
 {}
 
 void SelectHelper::SetTimeout(const std::chrono::microseconds &timeout) {
   using namespace std::chrono;
   m_end_time = steady_clock::time_point(steady_clock::now() + timeout);
 }
 
-void SelectHelper::FDSetRead(int fd) { m_fd_map[fd].read_set = true; }
+void SelectHelper::FDSetRead(lldb::socket_t fd) {
+  m_fd_map[fd].read_set = true;
+}
 
-void SelectHelper::FDSetWrite(int fd) { m_fd_map[fd].write_set = true; }
+void SelectHelper::FDSetWrite(lldb::socket_t fd) {
+  m_fd_map[fd].write_set = true;
+}
 
-void SelectHelper::FDSetError(int fd) { m_fd_map[fd].error_set = true; }
+void SelectHelper::FDSetError(lldb::socket_t fd) {
+  m_fd_map[fd].error_set = true;
+}
 
-bool SelectHelper::FDIsSetRead(int fd) const {
+bool SelectHelper::FDIsSetRead(lldb::socket_t fd) const {
   auto pos = m_fd_map.find(fd);
   if (pos != m_fd_map.end())
     return pos->second.read_is_set;
   else
     return false;
 }
 
-bool SelectHelper::FDIsSetWrite(int fd) const {
+bool SelectHelper::FDIsSetWrite(lldb::socket_t fd) const {
   auto pos = m_fd_map.find(fd);
   if (pos != m_fd_map.end())
     return pos->second.write_is_set;
   else
     return false;
 }
 
-bool SelectHelper::FDIsSetError(int fd) const {
+bool SelectHelper::FDIsSetError(lldb::socket_t fd) const {
   auto pos = m_fd_map.find(fd);
   if (pos != m_fd_map.end())
     return pos->second.error_is_set;
   else
     return false;
 }
 
+static void updateMaxFd(llvm::Optional<lldb::socket_t> &vold,
+                        lldb::socket_t vnew) {
+  if (!vold.hasValue())
+    vold = vnew;
+  else
+    vold = std::max(*vold, vnew);
+}
+
 lldb_private::Error SelectHelper::Select() {
   lldb_private::Error error;
 #ifdef _MSC_VER
   // On windows FD_SETSIZE limits the number of file descriptors, not their
   // numeric value.
   lldbassert(m_fd_map.size() <= FD_SETSIZE);
   if (m_fd_map.size() > FD_SETSIZE)
     return lldb_private::Error("Too many file descriptors for select()");
 #endif
 
-  int max_read_fd = -1;
-  int max_write_fd = -1;
-  int max_error_fd = -1;
-  int max_fd = -1;
+  llvm::Optional<lldb::socket_t> max_read_fd;
+  llvm::Optional<lldb::socket_t> max_write_fd;
+  llvm::Optional<lldb::socket_t> max_error_fd;
+  llvm::Optional<lldb::socket_t> max_fd;
   for (auto &pair : m_fd_map) {
     pair.second.PrepareForSelect();
-    const int fd = pair.first;
+    const lldb::socket_t fd = pair.first;
 #if !defined(__APPLE__) && !defined(_MSC_VER)
     lldbassert(fd < FD_SETSIZE);
     if (fd >= FD_SETSIZE) {
       error.SetErrorStringWithFormat("%i is too large for select()", fd);
       return error;
     }
 #endif
-    if (pair.second.read_set) {
-      max_read_fd = std::max<int>(fd, max_read_fd);
-      max_fd = std::max<int>(fd, max_fd);
-    }
-    if (pair.second.write_set) {
-      max_write_fd = std::max<int>(fd, max_write_fd);
-      max_fd = std::max<int>(fd, max_fd);
-    }
-    if (pair.second.error_set) {
-      max_error_fd = std::max<int>(fd, max_error_fd);
-      max_fd = std::max<int>(fd, max_fd);
-    }
+    if (pair.second.read_set)
+      updateMaxFd(max_read_fd, fd);
+    if (pair.second.write_set)
+      updateMaxFd(max_write_fd, fd);
+    if (pair.second.error_set)
+      updateMaxFd(max_error_fd, fd);
+    updateMaxFd(max_fd, fd);
   }
 
-  if (max_fd == -1) {
+  if (!max_fd.hasValue()) {
     error.SetErrorString("no valid file descriptors");
     return error;
   }
 
-  const int nfds = max_fd + 1;
+  const unsigned nfds = static_cast<unsigned>(*max_fd) + 1;
   fd_set *read_fdset_ptr = nullptr;
   fd_set *write_fdset_ptr = nullptr;
   fd_set *error_fdset_ptr = nullptr;
 //----------------------------------------------------------------------
 // Initialize and zero out the fdsets
 //----------------------------------------------------------------------
 #if defined(__APPLE__)
   llvm::SmallVector<fd_set, 1> read_fdset;
   llvm::SmallVector<fd_set, 1> write_fdset;
   llvm::SmallVector<fd_set, 1> error_fdset;
 
-  if (max_read_fd >= 0) {
+  if (max_read_fd.hasValue()) {
     read_fdset.resize((nfds / FD_SETSIZE) + 1);
     read_fdset_ptr = read_fdset.data();
   }
-  if (max_write_fd >= 0) {
+  if (max_write_fd.hasValue()) {
     write_fdset.resize((nfds / FD_SETSIZE) + 1);
     write_fdset_ptr = write_fdset.data();
   }
-  if (max_error_fd >= 0) {
+  if (max_error_fd.hasValue()) {
     error_fdset.resize((nfds / FD_SETSIZE) + 1);
     error_fdset_ptr = error_fdset.data();
   }
   for (auto &fd_set : read_fdset)
     FD_ZERO(&fd_set);
   for (auto &fd_set : write_fdset)
     FD_ZERO(&fd_set);
   for (auto &fd_set : error_fdset)
     FD_ZERO(&fd_set);
 #else
   fd_set read_fdset;
   fd_set write_fdset;
   fd_set error_fdset;
 
-  if (max_read_fd >= 0) {
+  if (max_read_fd.hasValue()) {
     FD_ZERO(&read_fdset);
     read_fdset_ptr = &read_fdset;
   }
-  if (max_write_fd >= 0) {
+  if (max_write_fd.hasValue()) {
     FD_ZERO(&write_fdset);
     write_fdset_ptr = &write_fdset;
   }
-  if (max_error_fd >= 0) {
+  if (max_error_fd.hasValue()) {
     FD_ZERO(&error_fdset);
     error_fdset_ptr = &error_fdset;
   }
 #endif
   //----------------------------------------------------------------------
   // Set the FD bits in the fdsets for read/write/error
   //----------------------------------------------------------------------
   for (auto &pair : m_fd_map) {
-    const int fd = pair.first;
+    const lldb::socket_t fd = pair.first;
 
     if (pair.second.read_set)
       FD_SET(fd, read_fdset_ptr);
 
     if (pair.second.write_set)
       FD_SET(fd, write_fdset_ptr);
 
     if (pair.second.error_set)

tools/lldb-mi/Platform.h

 //===-- Platform.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #pragma once
 
 #if defined(_MSC_VER)
 
 #include <eh.h>
 #include <inttypes.h>
 #include <io.h>
 #include <lldb/Host/HostGetOpt.h>
-#include <lldb/Host/windows/Windows.h>
+#include <lldb/Host/windows/windows.h>
 #include <signal.h>
 
 // This is not used by MI
 struct timeval {
   long tv_sec;
   long tv_usec;
 };