[clang] Change llvm::sys::Mutex implementation to use STL-provided mutexes.

[zturner]

Summary

Clang side changes to support LLVM mutex refactor. This accompanies revision D4033, and should be submitted at the same time.

[zturner]

Fix some compilation errors on Linux.

[zturner]

During an atexit handler, std::mutex cannot be used. This revision addresses this by changing to a mutex which is safe for use during shutdown.

[zturner]

Clang side changes accompanying the LLVM mutex refactor

lib/Frontend/ASTUnit.cpp

 #include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <atomic>
 #include <cstdio>
 #include <cstdlib>
 #include <sys/stat.h>
+
 using namespace clang;
 
 using llvm::TimeRecord;
 
 namespace {
   class SimpleTimer {
     bool WantTiming;
     TimeRecord Start;
struct OnDiskData {
     /// \brief Erase the preamble file.
     void CleanPreambleFile();
 
     /// \brief Erase temporary files and the preamble file.
     void Cleanup();
   };
 }
 
-static llvm::sys::SmartMutex<false> &getOnDiskMutex() {
-  static llvm::sys::SmartMutex<false> M(/* recursive = */ true);
+static llvm::sys::MutexBase &getOnDiskMutex() {
+#if defined(LLVM_ON_WIN32)
+  // The default mutex implementation on Windows cannot be used during an atexit
+  // handler.  The workaround is to use a critical section for this case.
+  static llvm::sys::CriticalSectionMutex M;
+#else
+  static llvm::sys::RecursiveMutex M;
+#endif
   return M;
 }
 
 static void cleanupOnDiskMapAtExit();
 
 typedef llvm::DenseMap<const ASTUnit *, OnDiskData *> OnDiskDataMap;
 static OnDiskDataMap &getOnDiskDataMap() {
   static OnDiskDataMap M;
if (*I == '\n')
       ++NumLines;
   }
   if (Buffer.back() != '\n')
     ++NumLines;
 }
 
 #ifndef NDEBUG
 ASTUnit::ConcurrencyState::ConcurrencyState() {
-  Mutex = new llvm::sys::MutexImpl(/*recursive=*/true);
+  Mutex = new llvm::sys::RecursiveMutex;
 }
 
 ASTUnit::ConcurrencyState::~ConcurrencyState() {
-  delete static_cast<llvm::sys::MutexImpl *>(Mutex);
+  delete static_cast<llvm::sys::RecursiveMutex *>(Mutex);
 }
 
 void ASTUnit::ConcurrencyState::start() {
-  bool acquired = static_cast<llvm::sys::MutexImpl *>(Mutex)->tryacquire();
+  bool acquired = static_cast<llvm::sys::RecursiveMutex *>(Mutex)->tryacquire();
   assert(acquired && "Concurrent access to ASTUnit!");
 }
 
 void ASTUnit::ConcurrencyState::finish() {
-  static_cast<llvm::sys::MutexImpl *>(Mutex)->release();
+  static_cast<llvm::sys::RecursiveMutex *>(Mutex)->release();
 }
 
 #else // NDEBUG
 
 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = 0; }
 ASTUnit::ConcurrencyState::~ConcurrencyState() {}
 void ASTUnit::ConcurrencyState::start() {}
 void ASTUnit::ConcurrencyState::finish() {}
 
 #endif

tools/libclang/CIndex.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 
 #ifdef __APPLE__
RefNamePieces buildPieces(unsigned NameFlags, bool IsMemberRefExpr,
   return Pieces;  
 }
 }
 
 //===----------------------------------------------------------------------===//
 // Misc. API hooks.
 //===----------------------------------------------------------------------===//               
 
-static llvm::sys::Mutex EnableMultithreadingMutex;
+static llvm::sys::RecursiveMutex EnableMultithreadingMutex;
 static bool EnabledMultithreading;
 
 static void fatal_error_handler(void *user_data, const std::string& reason,
                                 bool gen_crash_diag) {
   // Write the result out to stderr avoiding errs() because raw_ostreams can
   // call report_fatal_error.
   fprintf(stderr, "LIBCLANG FATAL ERROR: %s\n", reason.c_str());
   ::abort();
 }
 
 extern "C" {
 CXIndex clang_createIndex(int excludeDeclarationsFromPCH,
                           int displayDiagnostics) {
   // We use crash recovery to make some of our APIs more reliable, implicitly
   // enable it.
   if (!getenv("LIBCLANG_DISABLE_CRASH_RECOVERY"))
     llvm::CrashRecoveryContext::Enable();
 
   // Enable support for multithreading in LLVM.
   {
-    llvm::sys::ScopedLock L(EnableMultithreadingMutex);
+    llvm::MutexGuard L(EnableMultithreadingMutex);
     if (!EnabledMultithreading) {
       llvm::install_fatal_error_handler(fatal_error_handler, 0);
       llvm::llvm_start_multithreaded();
       EnabledMultithreading = true;
     }
   }
 
   CIndexer *CIdxr = new CIndexer();

 Logger &cxindex::Logger::operator<<(const llvm::format_object_base &Fmt) {
   LogOS << Fmt;
   return *this;
 }
 
 cxindex::Logger::~Logger() {
   LogOS.flush();
 
-  llvm::sys::ScopedLock L(EnableMultithreadingMutex);
+  llvm::MutexGuard L(EnableMultithreadingMutex);
 
   static llvm::TimeRecord sBeginTR = llvm::TimeRecord::getCurrentTime();
 
   raw_ostream &OS = llvm::errs();
   OS << "[libclang:" << Name << ':';
 
   // FIXME: Portability.
 #ifdef __APPLE__

tools/libclang/Indexing.cpp

static bool isEqual(const PPRegion &LHS, const PPRegion &RHS) {
       return LHS == RHS;
     }
   };
 }
 
 namespace {
 
 class SessionSkipBodyData {
-  llvm::sys::Mutex Mux;
+  llvm::sys::RecursiveMutex Mux;
   PPRegionSetTy ParsedRegions;
 
 public:
   SessionSkipBodyData() : Mux(/*recursive=*/false) {}
   ~SessionSkipBodyData() {
     //llvm::errs() << "RegionData: " << Skipped.size() << " - " << Skipped.getMemorySize() << "\n";
   }