Using a helper to make the double checked locking more legible

Summary:

Test Plan:

Reviewers:

Subscribers:

Tasks:

Tags:

Differential Revision: https://phabricator.intern.facebook.com/D57863981

Author: Kevin Frei

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

@@ -585,6 +585,10 @@ class DWARFUnit {
   /// hasn't already been done
   void extractDIEsIfNeeded(bool CUDieOnly);
 
+  /// extractAllDIEsHelper - helper to be invoked *only* from inside
+  /// tryExtractDIEsIfNeeded, which holds correct locks.
+  Error extractAllDIEsHelper();
+
   /// extractDIEsToVector - Appends all parsed DIEs to a vector.
   void extractDIEsToVector(bool AppendCUDie, bool AppendNonCUDIEs,
                            std::vector<DWARFDebugInfoEntry> &DIEs) const;

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

@@ -495,36 +495,66 @@ void DWARFUnit::extractDIEsIfNeeded(bool CUDieOnly) {
     Context.getRecoverableErrorHandler()(std::move(e));
 }
 
-Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) {
-  llvm::sys::ScopedReader FreeLock(CUDieFreeMutex);
+static bool DoubleCheckedRWLocker(llvm::sys::RWMutex &Mutex,
+                                  const std::function<bool()> &reader,
+                                  const std::function<void()> &writer) {
   {
-    llvm::sys::ScopedReader Lock(CUDieArrayMutex);
-    if ((CUDieOnly && !DieArray.empty()) || DieArray.size() > 1)
-      return Error::success(); // Already parsed.
+    llvm::sys::ScopedReader Lock(Mutex);
+    if (reader())
+      return true;
   }
+  llvm::sys::ScopedWriter Lock(Mutex);
+  if (reader())
+    return true;
+  // If we get here, then the reader function returned false. This means that
+  // no one else is currently writing to this data structure and it's safe for
+  // us to write to it now. We can use a scoped writer lock since there are no
+  // other readers or writers at this point.
+  writer();
+  return false;
+}
+
+Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) {
+  llvm::sys::ScopedReader FreeLock(CUDieFreeMutex);
   bool HasCUDie = false;
-  {
-    llvm::sys::ScopedWriter Lock(CUDieArrayMutex);
-    if ((CUDieOnly && !DieArray.empty()) || DieArray.size() > 1)
-      return Error::success(); // Already parsed.
-    HasCUDie = !DieArray.empty();
-    extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
-  }
-  {
-    llvm::sys::ScopedReader Lock(AllDieArrayMutex);
-    if (DieArray.empty())
-      return Error::success();
+  Error Result = Error::success();
 
-    if (HasCUDie)
-      return Error::success();
-  }
-  llvm::sys::ScopedWriter Lock(AllDieArrayMutex);
-  if (DieArray.empty())
-    return Error::success();
+  // Lambda to check if the CU DIE has been extracted already.
+  auto CheckIfCUDieExtracted = [this, CUDieOnly]() {
+    // True means already parsed.
+    return ((CUDieOnly && !DieArray.empty()) || DieArray.size() > 1);
+  };
 
-  if (HasCUDie)
-    return Error::success();
+  // Lambda to extract the CU DIE.
+  auto ExtractCUDie = [this, CUDieOnly, &HasCUDie]() {
+    HasCUDie = !DieArray.empty();
+    extractDIEsToVector(!HasCUDie, !CUDieOnly, DieArray);
+  };
+
+  // Safely check if the CU DIE has been extract already. If not, then extract
+  // it.
+  if (DoubleCheckedRWLocker(CUDieArrayMutex, CheckIfCUDieExtracted,
+                            ExtractCUDie))
+    return Result;
+
+  // Lambda to check if all DIEs have been extract already.
+  auto CheckIfAllDiesExtracted = [this, HasCUDie]() {
+    return (DieArray.empty() || HasCUDie);
+  };
+
+  // Lambda to extract all the DIEs using the helper function
+  auto ExtractAllDies = [this, &Result]() { Result = extractAllDIEsHelper(); };
+
+  // Safely check if *all* the DIEs have been parsed already. If not, then parse
+  // them.
+  DoubleCheckedRWLocker(AllDieArrayMutex, CheckIfAllDiesExtracted,
+                        ExtractAllDies);
+  return Result;
+}
 
+// This should only be used from the tryExtractDIEsIfNeeded function:
+// it must already have all the proper locks acquired.
+Error DWARFUnit::extractAllDIEsHelper() {
   // If CU DIE was just parsed, copy several attribute values from it.
   DWARFDie UnitDie(this, &DieArray[0]);
   if (std::optional<uint64_t> DWOId =