Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 67 insertions, 67 deletions

diff --git a/contrib/libs/llvm12/lib/Analysis/DependenceGraphBuilder.cpp b/contrib/libs/llvm12/lib/Analysis/DependenceGraphBuilder.cpp
index 0851a5d98c..6b90db4baf 100644
--- a/contrib/libs/llvm12/lib/Analysis/DependenceGraphBuilder.cpp
+++ b/contrib/libs/llvm12/lib/Analysis/DependenceGraphBuilder.cpp
@@ -140,74 +140,74 @@ template <class G> void AbstractDependenceGraphBuilder<G>::createPiBlocks() {
       if (*N == PiNode || NodesInSCC.count(N))
         continue;
 
-      enum Direction { 
-        Incoming,      // Incoming edges to the SCC 
-        Outgoing,      // Edges going ot of the SCC 
-        DirectionCount // To make the enum usable as an array index. 
-      }; 
-
-      // Use these flags to help us avoid creating redundant edges. If there 
-      // are more than one edges from an outside node to inside nodes, we only 
-      // keep one edge from that node to the pi-block node. Similarly, if 
-      // there are more than one edges from inside nodes to an outside node, 
-      // we only keep one edge from the pi-block node to the outside node. 
-      // There is a flag defined for each direction (incoming vs outgoing) and 
-      // for each type of edge supported, using a two-dimensional boolean 
-      // array. 
-      using EdgeKind = typename EdgeType::EdgeKind; 
-      EnumeratedArray<bool, EdgeKind> EdgeAlreadyCreated[DirectionCount]{false, 
-                                                                         false}; 
-
-      auto createEdgeOfKind = [this](NodeType &Src, NodeType &Dst, 
-                                     const EdgeKind K) { 
-        switch (K) { 
-        case EdgeKind::RegisterDefUse: 
-          createDefUseEdge(Src, Dst); 
-          break; 
-        case EdgeKind::MemoryDependence: 
-          createMemoryEdge(Src, Dst); 
-          break; 
-        case EdgeKind::Rooted: 
-          createRootedEdge(Src, Dst); 
-          break; 
-        default: 
-          llvm_unreachable("Unsupported type of edge."); 
-        } 
-      }; 
-
-      auto reconnectEdges = [&](NodeType *Src, NodeType *Dst, NodeType *New, 
-                                const Direction Dir) { 
-        if (!Src->hasEdgeTo(*Dst)) 
-          return; 
-        LLVM_DEBUG( 
-            dbgs() << "reconnecting(" 
-                   << (Dir == Direction::Incoming ? "incoming)" : "outgoing)") 
-                   << ":\nSrc:" << *Src << "\nDst:" << *Dst << "\nNew:" << *New 
-                   << "\n"); 
-        assert((Dir == Direction::Incoming || Dir == Direction::Outgoing) && 
-               "Invalid direction."); 
-
-        SmallVector<EdgeType *, 10> EL; 
-        Src->findEdgesTo(*Dst, EL); 
-        for (EdgeType *OldEdge : EL) { 
-          EdgeKind Kind = OldEdge->getKind(); 
-          if (!EdgeAlreadyCreated[Dir][Kind]) { 
-            if (Dir == Direction::Incoming) { 
-              createEdgeOfKind(*Src, *New, Kind); 
-              LLVM_DEBUG(dbgs() << "created edge from Src to New.\n"); 
-            } else if (Dir == Direction::Outgoing) { 
-              createEdgeOfKind(*New, *Dst, Kind); 
-              LLVM_DEBUG(dbgs() << "created edge from New to Dst.\n"); 
+      enum Direction {
+        Incoming,      // Incoming edges to the SCC
+        Outgoing,      // Edges going ot of the SCC
+        DirectionCount // To make the enum usable as an array index.
+      };
+
+      // Use these flags to help us avoid creating redundant edges. If there
+      // are more than one edges from an outside node to inside nodes, we only
+      // keep one edge from that node to the pi-block node. Similarly, if
+      // there are more than one edges from inside nodes to an outside node,
+      // we only keep one edge from the pi-block node to the outside node.
+      // There is a flag defined for each direction (incoming vs outgoing) and
+      // for each type of edge supported, using a two-dimensional boolean
+      // array.
+      using EdgeKind = typename EdgeType::EdgeKind;
+      EnumeratedArray<bool, EdgeKind> EdgeAlreadyCreated[DirectionCount]{false,
+                                                                         false};
+
+      auto createEdgeOfKind = [this](NodeType &Src, NodeType &Dst,
+                                     const EdgeKind K) {
+        switch (K) {
+        case EdgeKind::RegisterDefUse:
+          createDefUseEdge(Src, Dst);
+          break;
+        case EdgeKind::MemoryDependence:
+          createMemoryEdge(Src, Dst);
+          break;
+        case EdgeKind::Rooted:
+          createRootedEdge(Src, Dst);
+          break;
+        default:
+          llvm_unreachable("Unsupported type of edge.");
+        }
+      };
+
+      auto reconnectEdges = [&](NodeType *Src, NodeType *Dst, NodeType *New,
+                                const Direction Dir) {
+        if (!Src->hasEdgeTo(*Dst))
+          return;
+        LLVM_DEBUG(
+            dbgs() << "reconnecting("
+                   << (Dir == Direction::Incoming ? "incoming)" : "outgoing)")
+                   << ":\nSrc:" << *Src << "\nDst:" << *Dst << "\nNew:" << *New
+                   << "\n");
+        assert((Dir == Direction::Incoming || Dir == Direction::Outgoing) &&
+               "Invalid direction.");
+
+        SmallVector<EdgeType *, 10> EL;
+        Src->findEdgesTo(*Dst, EL);
+        for (EdgeType *OldEdge : EL) {
+          EdgeKind Kind = OldEdge->getKind();
+          if (!EdgeAlreadyCreated[Dir][Kind]) {
+            if (Dir == Direction::Incoming) {
+              createEdgeOfKind(*Src, *New, Kind);
+              LLVM_DEBUG(dbgs() << "created edge from Src to New.\n");
+            } else if (Dir == Direction::Outgoing) {
+              createEdgeOfKind(*New, *Dst, Kind);
+              LLVM_DEBUG(dbgs() << "created edge from New to Dst.\n");
             }
-            EdgeAlreadyCreated[Dir][Kind] = true; 
+            EdgeAlreadyCreated[Dir][Kind] = true;
           }
-          Src->removeEdge(*OldEdge); 
-          destroyEdge(*OldEdge); 
-          LLVM_DEBUG(dbgs() << "removed old edge between Src and Dst.\n\n"); 
-        } 
-      }; 
+          Src->removeEdge(*OldEdge);
+          destroyEdge(*OldEdge);
+          LLVM_DEBUG(dbgs() << "removed old edge between Src and Dst.\n\n");
+        }
+      };
 
-      for (NodeType *SCCNode : NL) { 
+      for (NodeType *SCCNode : NL) {
         // Process incoming edges incident to the pi-block node.
         reconnectEdges(N, SCCNode, &PiNode, Direction::Incoming);
 
@@ -491,14 +491,14 @@ void AbstractDependenceGraphBuilder<G>::sortNodesTopologically() {
       // Put members of the pi-block right after the pi-block itself, for
       // convenience.
       const NodeListType &PiBlockMembers = getNodesInPiBlock(*N);
-      llvm::append_range(NodesInPO, PiBlockMembers); 
+      llvm::append_range(NodesInPO, PiBlockMembers);
     }
     NodesInPO.push_back(N);
   }
 
   size_t OldSize = Graph.Nodes.size();
   Graph.Nodes.clear();
-  append_range(Graph.Nodes, reverse(NodesInPO)); 
+  append_range(Graph.Nodes, reverse(NodesInPO));
   if (Graph.Nodes.size() != OldSize)
     assert(false &&
            "Expected the number of nodes to stay the same after the sort");