format

Author: V-FEXrt

llvm/lib/Analysis/DXILResource.cpp

@@ -832,7 +832,8 @@ static bool isUpdateCounterIntrinsic(Function &F) {
 }
 
 void DXILResourceCounterDirectionMap::populate(Module &M, DXILBindingMap &DBM) {
-  std::vector<std::tuple<dxil::ResourceBindingInfo, ResourceCounterDirection, const Function*, const CallInst*>>
+  std::vector<std::tuple<dxil::ResourceBindingInfo, ResourceCounterDirection,
+                         const Function *, const CallInst *>>
       DiagCounterDirs;
 
   for (Function &F : M.functions()) {
@@ -867,50 +868,61 @@ void DXILResourceCounterDirectionMap::populate(Module &M, DXILBindingMap &DBM) {
   // unknown
   const auto RemoveEnd = std::remove_if(
       DiagCounterDirs.begin(), DiagCounterDirs.end(), [](const auto &Item) {
-        return std::get<ResourceCounterDirection>(Item) == ResourceCounterDirection::Unknown;
+        return std::get<ResourceCounterDirection>(Item) ==
+               ResourceCounterDirection::Unknown;
       });
 
   // Sort by the Binding and Direction for fast lookup
-  std::sort(DiagCounterDirs.begin(), RemoveEnd, [](const auto &LHS, const auto &RHS) {
-    const auto L = std::pair{std::get<dxil::ResourceBindingInfo>(LHS), std::get<ResourceCounterDirection>(LHS)};
-    const auto R = std::pair{std::get<dxil::ResourceBindingInfo>(RHS), std::get<ResourceCounterDirection>(RHS)};
-    return L < R;
-  });
+  std::sort(DiagCounterDirs.begin(), RemoveEnd,
+            [](const auto &LHS, const auto &RHS) {
+              const auto L = std::pair{std::get<dxil::ResourceBindingInfo>(LHS),
+                                       std::get<ResourceCounterDirection>(LHS)};
+              const auto R = std::pair{std::get<dxil::ResourceBindingInfo>(RHS),
+                                       std::get<ResourceCounterDirection>(RHS)};
+              return L < R;
+            });
 
   // Remove the duplicate entries. Since direction is considered for equality
   // a unique resource with more than one direction will not be deduped.
-  const auto UniqueEnd = std::unique(DiagCounterDirs.begin(), RemoveEnd, [](const auto &LHS, const auto &RHS) {
-    const auto L = std::pair{std::get<dxil::ResourceBindingInfo>(LHS), std::get<ResourceCounterDirection>(LHS)};
-    const auto R = std::pair{std::get<dxil::ResourceBindingInfo>(RHS), std::get<ResourceCounterDirection>(RHS)};
-    return L == R;
-  });
+  const auto UniqueEnd = std::unique(
+      DiagCounterDirs.begin(), RemoveEnd, [](const auto &LHS, const auto &RHS) {
+        const auto L = std::pair{std::get<dxil::ResourceBindingInfo>(LHS),
+                                 std::get<ResourceCounterDirection>(LHS)};
+        const auto R = std::pair{std::get<dxil::ResourceBindingInfo>(RHS),
+                                 std::get<ResourceCounterDirection>(RHS)};
+        return L == R;
+      });
 
   // Actually erase the items invalidated by remove_if + unique
   DiagCounterDirs.erase(UniqueEnd, DiagCounterDirs.end());
 
   // If any duplicate entries still exist at this point then it must be a
   // resource that was both incremented and decremented which is not allowed.
-  const auto DuplicateEntry = std::adjacent_find(
-      DiagCounterDirs.begin(), DiagCounterDirs.end(),
-      [](const auto &LHS, const auto &RHS) {
-      return std::get<dxil::ResourceBindingInfo>(LHS) == std::get<dxil::ResourceBindingInfo>(RHS);
-  });
+  const auto DuplicateEntry =
+      std::adjacent_find(DiagCounterDirs.begin(), DiagCounterDirs.end(),
+                         [](const auto &LHS, const auto &RHS) {
+                           return std::get<dxil::ResourceBindingInfo>(LHS) ==
+                                  std::get<dxil::ResourceBindingInfo>(RHS);
+                         });
 
   // Copy the results into the final vec
   CounterDirections.clear();
   CounterDirections.reserve(DiagCounterDirs.size());
-  std::transform(DiagCounterDirs.begin(), DiagCounterDirs.end(), std::back_inserter(CounterDirections), [](const auto &Item){
-    return std::pair{std::get<dxil::ResourceBindingInfo>(Item), std::get<ResourceCounterDirection>(Item)};
-  });
+  std::transform(DiagCounterDirs.begin(), DiagCounterDirs.end(),
+                 std::back_inserter(CounterDirections), [](const auto &Item) {
+                   return std::pair{std::get<dxil::ResourceBindingInfo>(Item),
+                                    std::get<ResourceCounterDirection>(Item)};
+                 });
 
   if (DuplicateEntry == DiagCounterDirs.end())
     return;
 
-  const Function* F = std::get<const Function*>(*DuplicateEntry);
-  const CallInst* CI = std::get<const CallInst*>(*DuplicateEntry);
+  const Function *F = std::get<const Function *>(*DuplicateEntry);
+  const CallInst *CI = std::get<const CallInst *>(*DuplicateEntry);
   StringRef Message = "RWStructuredBuffers may increment or decrement their "
                       "counters, but not both.";
-  M.getContext().diagnose(DiagnosticInfoGenericWithLoc(Message, *F, CI->getDebugLoc()));
+  M.getContext().diagnose(
+      DiagnosticInfoGenericWithLoc(Message, *F, CI->getDebugLoc()));
 }
 
 void DXILResourceCounterDirectionWrapperPass::getAnalysisUsage(