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

1 files changed, 75 insertions, 75 deletions

diff --git a/contrib/libs/llvm12/lib/Transforms/IPO/HotColdSplitting.cpp b/contrib/libs/llvm12/lib/Transforms/IPO/HotColdSplitting.cpp
index 0f91173aab..aa708ee520 100644
--- a/contrib/libs/llvm12/lib/Transforms/IPO/HotColdSplitting.cpp
+++ b/contrib/libs/llvm12/lib/Transforms/IPO/HotColdSplitting.cpp
@@ -67,9 +67,9 @@
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Transforms/Utils/ValueMapper.h"
 #include <algorithm>
-#include <limits> 
+#include <limits>
 #include <cassert>
-#include <string> 
+#include <string>
 
 #define DEBUG_TYPE "hotcoldsplit"
 
@@ -78,29 +78,29 @@ STATISTIC(NumColdRegionsOutlined, "Number of cold regions outlined.");
 
 using namespace llvm;
 
-static cl::opt<bool> EnableStaticAnalysis("hot-cold-static-analysis", 
-                                          cl::init(true), cl::Hidden); 
+static cl::opt<bool> EnableStaticAnalysis("hot-cold-static-analysis",
+                                          cl::init(true), cl::Hidden);
 
 static cl::opt<int>
     SplittingThreshold("hotcoldsplit-threshold", cl::init(2), cl::Hidden,
                        cl::desc("Base penalty for splitting cold code (as a "
                                 "multiple of TCC_Basic)"));
 
-static cl::opt<bool> EnableColdSection( 
-    "enable-cold-section", cl::init(false), cl::Hidden, 
-    cl::desc("Enable placement of extracted cold functions" 
-             " into a separate section after hot-cold splitting.")); 
- 
-static cl::opt<std::string> 
-    ColdSectionName("hotcoldsplit-cold-section-name", cl::init("__llvm_cold"), 
-                    cl::Hidden, 
-                    cl::desc("Name for the section containing cold functions " 
-                             "extracted by hot-cold splitting.")); 
- 
-static cl::opt<int> MaxParametersForSplit( 
-    "hotcoldsplit-max-params", cl::init(4), cl::Hidden, 
-    cl::desc("Maximum number of parameters for a split function")); 
- 
+static cl::opt<bool> EnableColdSection(
+    "enable-cold-section", cl::init(false), cl::Hidden,
+    cl::desc("Enable placement of extracted cold functions"
+             " into a separate section after hot-cold splitting."));
+
+static cl::opt<std::string>
+    ColdSectionName("hotcoldsplit-cold-section-name", cl::init("__llvm_cold"),
+                    cl::Hidden,
+                    cl::desc("Name for the section containing cold functions "
+                             "extracted by hot-cold splitting."));
+
+static cl::opt<int> MaxParametersForSplit(
+    "hotcoldsplit-max-params", cl::init(4), cl::Hidden,
+    cl::desc("Maximum number of parameters for a split function"));
+
 namespace {
 // Same as blockEndsInUnreachable in CodeGen/BranchFolding.cpp. Do not modify
 // this function unless you modify the MBB version as well.
@@ -237,11 +237,11 @@ bool HotColdSplitting::shouldOutlineFrom(const Function &F) const {
 }
 
 /// Get the benefit score of outlining \p Region.
-static InstructionCost getOutliningBenefit(ArrayRef<BasicBlock *> Region, 
-                                           TargetTransformInfo &TTI) { 
+static InstructionCost getOutliningBenefit(ArrayRef<BasicBlock *> Region,
+                                           TargetTransformInfo &TTI) {
   // Sum up the code size costs of non-terminator instructions. Tight coupling
   // with \ref getOutliningPenalty is needed to model the costs of terminators.
-  InstructionCost Benefit = 0; 
+  InstructionCost Benefit = 0;
   for (BasicBlock *BB : Region)
     for (Instruction &I : BB->instructionsWithoutDebug())
       if (&I != BB->getTerminator())
@@ -275,55 +275,55 @@ static int getOutliningPenalty(ArrayRef<BasicBlock *> Region,
     }
 
     for (BasicBlock *SuccBB : successors(BB)) {
-      if (!is_contained(Region, SuccBB)) { 
+      if (!is_contained(Region, SuccBB)) {
         NoBlocksReturn = false;
         SuccsOutsideRegion.insert(SuccBB);
       }
     }
   }
 
-  // Count the number of phis in exit blocks with >= 2 incoming values from the 
-  // outlining region. These phis are split (\ref severSplitPHINodesOfExits), 
-  // and new outputs are created to supply the split phis. CodeExtractor can't 
-  // report these new outputs until extraction begins, but it's important to 
-  // factor the cost of the outputs into the cost calculation. 
-  unsigned NumSplitExitPhis = 0; 
-  for (BasicBlock *ExitBB : SuccsOutsideRegion) { 
-    for (PHINode &PN : ExitBB->phis()) { 
-      // Find all incoming values from the outlining region. 
-      int NumIncomingVals = 0; 
-      for (unsigned i = 0; i < PN.getNumIncomingValues(); ++i) 
-        if (find(Region, PN.getIncomingBlock(i)) != Region.end()) { 
-          ++NumIncomingVals; 
-          if (NumIncomingVals > 1) { 
-            ++NumSplitExitPhis; 
-            break; 
-          } 
-        } 
-    } 
-  } 
- 
-  // Apply a penalty for calling the split function. Factor in the cost of 
-  // materializing all of the parameters. 
-  int NumOutputsAndSplitPhis = NumOutputs + NumSplitExitPhis; 
-  int NumParams = NumInputs + NumOutputsAndSplitPhis; 
-  if (NumParams > MaxParametersForSplit) { 
-    LLVM_DEBUG(dbgs() << NumInputs << " inputs and " << NumOutputsAndSplitPhis 
-                      << " outputs exceeds parameter limit (" 
-                      << MaxParametersForSplit << ")\n"); 
-    return std::numeric_limits<int>::max(); 
-  } 
-  const int CostForArgMaterialization = 2 * TargetTransformInfo::TCC_Basic; 
-  LLVM_DEBUG(dbgs() << "Applying penalty for: " << NumParams << " params\n"); 
-  Penalty += CostForArgMaterialization * NumParams; 
- 
-  // Apply the typical code size cost for an output alloca and its associated 
-  // reload in the caller. Also penalize the associated store in the callee. 
-  LLVM_DEBUG(dbgs() << "Applying penalty for: " << NumOutputsAndSplitPhis 
-                    << " outputs/split phis\n"); 
-  const int CostForRegionOutput = 3 * TargetTransformInfo::TCC_Basic; 
-  Penalty += CostForRegionOutput * NumOutputsAndSplitPhis; 
- 
+  // Count the number of phis in exit blocks with >= 2 incoming values from the
+  // outlining region. These phis are split (\ref severSplitPHINodesOfExits),
+  // and new outputs are created to supply the split phis. CodeExtractor can't
+  // report these new outputs until extraction begins, but it's important to
+  // factor the cost of the outputs into the cost calculation.
+  unsigned NumSplitExitPhis = 0;
+  for (BasicBlock *ExitBB : SuccsOutsideRegion) {
+    for (PHINode &PN : ExitBB->phis()) {
+      // Find all incoming values from the outlining region.
+      int NumIncomingVals = 0;
+      for (unsigned i = 0; i < PN.getNumIncomingValues(); ++i)
+        if (find(Region, PN.getIncomingBlock(i)) != Region.end()) {
+          ++NumIncomingVals;
+          if (NumIncomingVals > 1) {
+            ++NumSplitExitPhis;
+            break;
+          }
+        }
+    }
+  }
+
+  // Apply a penalty for calling the split function. Factor in the cost of
+  // materializing all of the parameters.
+  int NumOutputsAndSplitPhis = NumOutputs + NumSplitExitPhis;
+  int NumParams = NumInputs + NumOutputsAndSplitPhis;
+  if (NumParams > MaxParametersForSplit) {
+    LLVM_DEBUG(dbgs() << NumInputs << " inputs and " << NumOutputsAndSplitPhis
+                      << " outputs exceeds parameter limit ("
+                      << MaxParametersForSplit << ")\n");
+    return std::numeric_limits<int>::max();
+  }
+  const int CostForArgMaterialization = 2 * TargetTransformInfo::TCC_Basic;
+  LLVM_DEBUG(dbgs() << "Applying penalty for: " << NumParams << " params\n");
+  Penalty += CostForArgMaterialization * NumParams;
+
+  // Apply the typical code size cost for an output alloca and its associated
+  // reload in the caller. Also penalize the associated store in the callee.
+  LLVM_DEBUG(dbgs() << "Applying penalty for: " << NumOutputsAndSplitPhis
+                    << " outputs/split phis\n");
+  const int CostForRegionOutput = 3 * TargetTransformInfo::TCC_Basic;
+  Penalty += CostForRegionOutput * NumOutputsAndSplitPhis;
+
   // Apply a `noreturn` bonus.
   if (NoBlocksReturn) {
     LLVM_DEBUG(dbgs() << "Applying bonus for: " << Region.size()
@@ -333,7 +333,7 @@ static int getOutliningPenalty(ArrayRef<BasicBlock *> Region,
 
   // Apply a penalty for having more than one successor outside of the region.
   // This penalty accounts for the switch needed in the caller.
-  if (SuccsOutsideRegion.size() > 1) { 
+  if (SuccsOutsideRegion.size() > 1) {
     LLVM_DEBUG(dbgs() << "Applying penalty for: " << SuccsOutsideRegion.size()
                       << " non-region successors\n");
     Penalty += (SuccsOutsideRegion.size() - 1) * TargetTransformInfo::TCC_Basic;
@@ -358,12 +358,12 @@ Function *HotColdSplitting::extractColdRegion(
   // splitting.
   SetVector<Value *> Inputs, Outputs, Sinks;
   CE.findInputsOutputs(Inputs, Outputs, Sinks);
-  InstructionCost OutliningBenefit = getOutliningBenefit(Region, TTI); 
+  InstructionCost OutliningBenefit = getOutliningBenefit(Region, TTI);
   int OutliningPenalty =
       getOutliningPenalty(Region, Inputs.size(), Outputs.size());
   LLVM_DEBUG(dbgs() << "Split profitability: benefit = " << OutliningBenefit
                     << ", penalty = " << OutliningPenalty << "\n");
-  if (!OutliningBenefit.isValid() || OutliningBenefit <= OutliningPenalty) 
+  if (!OutliningBenefit.isValid() || OutliningBenefit <= OutliningPenalty)
     return nullptr;
 
   Function *OrigF = Region[0]->getParent();
@@ -377,12 +377,12 @@ Function *HotColdSplitting::extractColdRegion(
     }
     CI->setIsNoInline();
 
-    if (EnableColdSection) 
-      OutF->setSection(ColdSectionName); 
-    else { 
-      if (OrigF->hasSection()) 
-        OutF->setSection(OrigF->getSection()); 
-    } 
+    if (EnableColdSection)
+      OutF->setSection(ColdSectionName);
+    else {
+      if (OrigF->hasSection())
+        OutF->setSection(OrigF->getSection());
+    }
 
     markFunctionCold(*OutF, BFI != nullptr);
 
@@ -625,7 +625,7 @@ bool HotColdSplitting::outlineColdRegions(Function &F, bool HasProfileSummary) {
       continue;
 
     bool Cold = (BFI && PSI->isColdBlock(BB, BFI)) ||
-                (EnableStaticAnalysis && unlikelyExecuted(*BB)); 
+                (EnableStaticAnalysis && unlikelyExecuted(*BB));
     if (!Cold)
       continue;