[NFC, StackSafety] Change type of internal container

[vitalybuka]

Summary

Depends on D80771.

[vitalybuka]

remove random include

[eugenis]

llvm/lib/Analysis/StackSafetyAnalysis.cpp

143

Why not DenseMap, do you expect this to use less memory at very small sizes?

[vitalybuka]

llvm/lib/Analysis/StackSafetyAnalysis.cpp

143

DenseMap is good for small vales, key, here values are quite fat.
Also allocates container are iterated 1-2 times so they are not critical for performance.

[eugenis]

Makes sense, LGTM.
Somehow I thought that UseInfo was a pointer...

[vitalybuka]

rebase

[mehdi_amini]

Sorry I had to revert in f9bb101d394d : this seems to be breaking gcc 5 build (hopefully I got the right patch?) See here: https://buildkite.com/mlir/mlir-core/builds/5364#d4d067e0-6acd-4754-8a3d-003fbae06695

[vitalybuka]

Thanks.

In D80847#2070123, @mehdi_amini wrote:

Sorry I had to revert in f9bb101d394d : this seems to be breaking gcc 5 build (hopefully I got the right patch?) See here: https://buildkite.com/mlir/mlir-core/builds/5364#d4d067e0-6acd-4754-8a3d-003fbae06695

llvm/lib/Analysis/StackSafetyAnalysis.cpp

 struct UseInfo {
   // Access range if the address (alloca or parameters).
   // It is allowed to be empty-set when there are no known accesses.
   ConstantRange Range;
 
   // List of calls which pass address as an argument.
   SmallVector<PassAsArgInfo, 4> Calls;
 
-  explicit UseInfo(unsigned PointerSize) : Range{PointerSize, false} {}
+  UseInfo(unsigned PointerSize) : Range{PointerSize, false} {}
 
   void updateRange(const ConstantRange &R) {
     assert(!R.isUpperSignWrapped());
     Range = Range.unionWith(R);
     assert(!Range.isUpperSignWrapped());
   }
 };
 
if (Overflow)
       return R;
   }
   R = ConstantRange(APInt::getNullValue(PointerSize), APSize);
   assert(!isUnsafe(R));
   return R;
 }
 
 struct FunctionInfo {
-  SmallVector<UseInfo, 4> Allocas;
+  std::map<const AllocaInst *, UseInfo> Allocas;
   SmallVector<UseInfo, 4> Params;
   // TODO: describe return value as depending on one or more of its arguments.
 
   // StackSafetyDataFlowAnalysis counter stored here for faster access.
   int UpdateCount = 0;
 
   void print(raw_ostream &O, StringRef Name, const Function *F) const {
     // TODO: Consider different printout format after
     // StackSafetyDataFlowAnalysis. Calls and parameters are irrelevant then.
     O << "  @" << Name << ((F && F->isDSOLocal()) ? "" : " dso_preemptable")
       << ((F && F->isInterposable()) ? " interposable" : "") << "\n";
 
     O << "    args uses:\n";
     size_t Pos = 0;
     for (auto &P : Params) {
       StringRef Name = "<N/A>";
       if (F)
         Name = F->getArg(Pos)->getName();
       O << "      " << Name << "[]: " << P << "\n";
       ++Pos;
     }
 
     O << "    allocas uses:\n";
     if (F) {
-      size_t Pos = 0;
       for (auto &I : instructions(F)) {
         if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
-          auto &AS = Allocas[Pos];
+          auto &AS = Allocas.find(AI)->second;
           O << "      " << AI->getName() << "["
             << getStaticAllocaSizeRange(*AI).getUpper() << "]: " << AS << "\n";
-          ++Pos;
         }
       }
     } else {
       assert(Allocas.empty());
     }
   }
 };
 
FunctionInfo StackSafetyLocalAnalysis::run() {
   FunctionInfo Info;
   assert(!F.isDeclaration() &&
          "Can't run StackSafety on a function declaration");
 
   LLVM_DEBUG(dbgs() << "[StackSafety] " << F.getName() << "\n");
 
   for (auto &I : instructions(F)) {
     if (auto *AI = dyn_cast<AllocaInst>(&I)) {
-      Info.Allocas.emplace_back(PointerSize);
-      UseInfo &AS = Info.Allocas.back();
+      UseInfo &AS = Info.Allocas.emplace(AI, PointerSize).first->second;
       analyzeAllUses(AI, AS);
     }
   }
 
   for (Argument &A : make_range(F.arg_begin(), F.arg_end())) {
     Info.Params.emplace_back(PointerSize);
     UseInfo &PS = Info.Params.back();
     analyzeAllUses(&A, PS);
GVToSSI createGlobalStackSafetyInfo(
   uint32_t PointerSize = Copy.begin()
                              ->first->getParent()
                              ->getDataLayout()
                              .getMaxPointerSizeInBits();
   StackSafetyDataFlowAnalysis SSDFA(PointerSize, std::move(Copy));
 
   for (auto &F : SSDFA.run()) {
     auto FI = F.second;
-    size_t Pos = 0;
     auto &SrcF = Functions[F.first];
-    for (auto &A : FI.Allocas) {
+    for (auto &KV : FI.Allocas) {
+      auto &A = KV.second;
       resolveAllCalls(A);
       for (auto &C : A.Calls) {
         A.updateRange(
             SSDFA.getArgumentAccessRange(C.Callee, C.ParamNo, C.Offset));
       }
       // FIXME: This is needed only to preserve calls in print() results.
-      A.Calls = SrcF.Allocas[Pos].Calls;
-      ++Pos;
+      A.Calls = SrcF.Allocas.find(KV.first)->second.Calls;
     }
-    Pos = 0;
+    size_t Pos = 0;
     for (auto &P : FI.Params) {
       P.Calls = SrcF.Params[Pos].Calls;
       ++Pos;
     }
     SSI[F.first] = std::move(FI);
   }
 
   return SSI;
if (!Info) {
     for (auto &F : M->functions()) {
       if (!F.isDeclaration()) {
         auto FI = GetSSI(F).getInfo().Info;
         Functions.emplace(&F, std::move(FI));
       }
     }
     Info.reset(
         new InfoTy{createGlobalStackSafetyInfo(std::move(Functions)), {}});
-    for (auto &KV : Info->Info) {
-      if (!KV.first->isDeclaration()) {
-        size_t Pos = 0;
-        // FIXME: Convert FunctionInfo::Allocas into map<AllocaInst*, UseInfo>
-        // and do not rely on alloca index.
-        for (auto &I : instructions(*cast<Function>(KV.first))) {
-          if (const auto &AI = dyn_cast<AllocaInst>(&I)) {
-            if (getStaticAllocaSizeRange(*AI).contains(
-                    KV.second.Allocas[Pos].Range)) {
-              Info->SafeAllocas.insert(AI);
-            }
-            ++Pos;
-          }
-        }
-      }
+    for (auto &FnKV : Info->Info) {
+      for (auto &KV : FnKV.second.Allocas) {
+        const AllocaInst *AI = KV.first;
+        if (getStaticAllocaSizeRange(*AI).contains(KV.second.Range))
     }
     if (StackSafetyPrint)
       print(errs());
   }
   return *Info;
 }
 
 StackSafetyGlobalInfo::StackSafetyGlobalInfo() = default;