Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 114 insertions, 114 deletions

diff --git a/contrib/libs/llvm12/lib/Support/DeltaAlgorithm.cpp b/contrib/libs/llvm12/lib/Support/DeltaAlgorithm.cpp
index 1d24165798b..6aee69f4340 100644
--- a/contrib/libs/llvm12/lib/Support/DeltaAlgorithm.cpp
+++ b/contrib/libs/llvm12/lib/Support/DeltaAlgorithm.cpp
@@ -1,114 +1,114 @@
-//===--- DeltaAlgorithm.cpp - A Set Minimization Algorithm -----*- C++ -*--===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-//===----------------------------------------------------------------------===// 
- 
-#include "llvm/ADT/DeltaAlgorithm.h" 
-#include <algorithm> 
-#include <iterator> 
-#include <set> 
-using namespace llvm; 
- 
-DeltaAlgorithm::~DeltaAlgorithm() { 
-} 
- 
-bool DeltaAlgorithm::GetTestResult(const changeset_ty &Changes) { 
-  if (FailedTestsCache.count(Changes)) 
-    return false; 
- 
-  bool Result = ExecuteOneTest(Changes); 
-  if (!Result) 
-    FailedTestsCache.insert(Changes); 
- 
-  return Result; 
-} 
- 
-void DeltaAlgorithm::Split(const changeset_ty &S, changesetlist_ty &Res) { 
-  // FIXME: Allow clients to provide heuristics for improved splitting. 
- 
-  // FIXME: This is really slow. 
-  changeset_ty LHS, RHS; 
-  unsigned idx = 0, N = S.size() / 2; 
-  for (changeset_ty::const_iterator it = S.begin(), 
-         ie = S.end(); it != ie; ++it, ++idx) 
-    ((idx < N) ? LHS : RHS).insert(*it); 
-  if (!LHS.empty()) 
-    Res.push_back(LHS); 
-  if (!RHS.empty()) 
-    Res.push_back(RHS); 
-} 
- 
-DeltaAlgorithm::changeset_ty 
-DeltaAlgorithm::Delta(const changeset_ty &Changes, 
-                      const changesetlist_ty &Sets) { 
-  // Invariant: union(Res) == Changes 
-  UpdatedSearchState(Changes, Sets); 
- 
-  // If there is nothing left we can remove, we are done. 
-  if (Sets.size() <= 1) 
-    return Changes; 
- 
-  // Look for a passing subset. 
-  changeset_ty Res; 
-  if (Search(Changes, Sets, Res)) 
-    return Res; 
- 
-  // Otherwise, partition the sets if possible; if not we are done. 
-  changesetlist_ty SplitSets; 
-  for (changesetlist_ty::const_iterator it = Sets.begin(), 
-         ie = Sets.end(); it != ie; ++it) 
-    Split(*it, SplitSets); 
-  if (SplitSets.size() == Sets.size()) 
-    return Changes; 
- 
-  return Delta(Changes, SplitSets); 
-} 
- 
-bool DeltaAlgorithm::Search(const changeset_ty &Changes, 
-                            const changesetlist_ty &Sets, 
-                            changeset_ty &Res) { 
-  // FIXME: Parallelize. 
-  for (changesetlist_ty::const_iterator it = Sets.begin(), 
-         ie = Sets.end(); it != ie; ++it) { 
-    // If the test passes on this subset alone, recurse. 
-    if (GetTestResult(*it)) { 
-      changesetlist_ty Sets; 
-      Split(*it, Sets); 
-      Res = Delta(*it, Sets); 
-      return true; 
-    } 
- 
-    // Otherwise, if we have more than two sets, see if test passes on the 
-    // complement. 
-    if (Sets.size() > 2) { 
-      // FIXME: This is really slow. 
-      changeset_ty Complement; 
-      std::set_difference( 
-        Changes.begin(), Changes.end(), it->begin(), it->end(), 
-        std::insert_iterator<changeset_ty>(Complement, Complement.begin())); 
-      if (GetTestResult(Complement)) { 
-        changesetlist_ty ComplementSets; 
-        ComplementSets.insert(ComplementSets.end(), Sets.begin(), it); 
-        ComplementSets.insert(ComplementSets.end(), it + 1, Sets.end()); 
-        Res = Delta(Complement, ComplementSets); 
-        return true; 
-      } 
-    } 
-  } 
- 
-  return false; 
-} 
- 
-DeltaAlgorithm::changeset_ty DeltaAlgorithm::Run(const changeset_ty &Changes) { 
-  // Check empty set first to quickly find poor test functions. 
-  if (GetTestResult(changeset_ty())) 
-    return changeset_ty(); 
- 
-  // Otherwise run the real delta algorithm. 
-  changesetlist_ty Sets; 
-  Split(Changes, Sets); 
- 
-  return Delta(Changes, Sets); 
-} 
+//===--- DeltaAlgorithm.cpp - A Set Minimization Algorithm -----*- C++ -*--===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/DeltaAlgorithm.h"
+#include <algorithm>
+#include <iterator>
+#include <set>
+using namespace llvm;
+
+DeltaAlgorithm::~DeltaAlgorithm() {
+}
+
+bool DeltaAlgorithm::GetTestResult(const changeset_ty &Changes) {
+  if (FailedTestsCache.count(Changes))
+    return false;
+
+  bool Result = ExecuteOneTest(Changes);
+  if (!Result)
+    FailedTestsCache.insert(Changes);
+
+  return Result;
+}
+
+void DeltaAlgorithm::Split(const changeset_ty &S, changesetlist_ty &Res) {
+  // FIXME: Allow clients to provide heuristics for improved splitting.
+
+  // FIXME: This is really slow.
+  changeset_ty LHS, RHS;
+  unsigned idx = 0, N = S.size() / 2;
+  for (changeset_ty::const_iterator it = S.begin(),
+         ie = S.end(); it != ie; ++it, ++idx)
+    ((idx < N) ? LHS : RHS).insert(*it);
+  if (!LHS.empty())
+    Res.push_back(LHS);
+  if (!RHS.empty())
+    Res.push_back(RHS);
+}
+
+DeltaAlgorithm::changeset_ty
+DeltaAlgorithm::Delta(const changeset_ty &Changes,
+                      const changesetlist_ty &Sets) {
+  // Invariant: union(Res) == Changes
+  UpdatedSearchState(Changes, Sets);
+
+  // If there is nothing left we can remove, we are done.
+  if (Sets.size() <= 1)
+    return Changes;
+
+  // Look for a passing subset.
+  changeset_ty Res;
+  if (Search(Changes, Sets, Res))
+    return Res;
+
+  // Otherwise, partition the sets if possible; if not we are done.
+  changesetlist_ty SplitSets;
+  for (changesetlist_ty::const_iterator it = Sets.begin(),
+         ie = Sets.end(); it != ie; ++it)
+    Split(*it, SplitSets);
+  if (SplitSets.size() == Sets.size())
+    return Changes;
+
+  return Delta(Changes, SplitSets);
+}
+
+bool DeltaAlgorithm::Search(const changeset_ty &Changes,
+                            const changesetlist_ty &Sets,
+                            changeset_ty &Res) {
+  // FIXME: Parallelize.
+  for (changesetlist_ty::const_iterator it = Sets.begin(),
+         ie = Sets.end(); it != ie; ++it) {
+    // If the test passes on this subset alone, recurse.
+    if (GetTestResult(*it)) {
+      changesetlist_ty Sets;
+      Split(*it, Sets);
+      Res = Delta(*it, Sets);
+      return true;
+    }
+
+    // Otherwise, if we have more than two sets, see if test passes on the
+    // complement.
+    if (Sets.size() > 2) {
+      // FIXME: This is really slow.
+      changeset_ty Complement;
+      std::set_difference(
+        Changes.begin(), Changes.end(), it->begin(), it->end(),
+        std::insert_iterator<changeset_ty>(Complement, Complement.begin()));
+      if (GetTestResult(Complement)) {
+        changesetlist_ty ComplementSets;
+        ComplementSets.insert(ComplementSets.end(), Sets.begin(), it);
+        ComplementSets.insert(ComplementSets.end(), it + 1, Sets.end());
+        Res = Delta(Complement, ComplementSets);
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+DeltaAlgorithm::changeset_ty DeltaAlgorithm::Run(const changeset_ty &Changes) {
+  // Check empty set first to quickly find poor test functions.
+  if (GetTestResult(changeset_ty()))
+    return changeset_ty();
+
+  // Otherwise run the real delta algorithm.
+  changesetlist_ty Sets;
+  Split(Changes, Sets);
+
+  return Delta(Changes, Sets);
+}