[StackSafety] Skip non-pointer parameters

[vitalybuka]

Summary

Depends on D80908.

[eugenis]

LGTM

llvm/lib/Analysis/StackSafetyAnalysis.cpp

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <memory>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "stack-safety"
 
ConstantRange getStaticAllocaSizeRange(const AllocaInst &AI) {
   }
   R = ConstantRange(APInt::getNullValue(PointerSize), APSize);
   assert(!isUnsafe(R));
   return R;
 }
 
 struct FunctionInfo {
   std::map<const AllocaInst *, UseInfo> Allocas;
-  SmallVector<UseInfo, 4> Params;
+  std::map<uint32_t, UseInfo> 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>";
+    for (auto &KV : Params) {
+      O << "      ";
       if (F)
-        Name = F->getArg(Pos)->getName();
-      O << "      " << Name << "[]: " << P << "\n";
-      ++Pos;
+        O << F->getArg(KV.first)->getName();
+      else
+        O << formatv("arg{0}", KV.first);
+      O << "[]: " << KV.second << "\n";
     }
 
     O << "    allocas uses:\n";
     if (F) {
       for (auto &I : instructions(F)) {
         if (const AllocaInst *AI = dyn_cast<AllocaInst>(&I)) {
           auto &AS = Allocas.find(AI)->second;
           O << "      " << AI->getName() << "["
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)) {
-      UseInfo &AS = Info.Allocas.emplace(AI, PointerSize).first->second;
-      analyzeAllUses(AI, AS);
+      auto &UI = Info.Allocas.emplace(AI, PointerSize).first->second;
+      analyzeAllUses(AI, UI);
     }
   }
 
   for (Argument &A : make_range(F.arg_begin(), F.arg_end())) {
-    Info.Params.emplace_back(PointerSize);
-    UseInfo &PS = Info.Params.back();
-    analyzeAllUses(&A, PS);
+    if (A.getType()->isPointerTy()) {
+      auto &UI = Info.Params.emplace(A.getArgNo(), PointerSize).first->second;
+      analyzeAllUses(&A, UI);
+    }
   }
 
   LLVM_DEBUG(Info.print(dbgs(), F.getName(), &F));
   LLVM_DEBUG(dbgs() << "[StackSafety] done\n");
   return Info;
 }
 
 class StackSafetyDataFlowAnalysis {
   using FunctionMap = std::map<const GlobalValue *, FunctionInfo>;
 
   FunctionMap Functions;
   const ConstantRange UnknownRange;
 
   // Callee-to-Caller multimap.
   DenseMap<const GlobalValue *, SmallVector<const GlobalValue *, 4>> Callers;
   SetVector<const GlobalValue *> WorkList;
 
-
   bool updateOneUse(UseInfo &US, bool UpdateToFullSet);
   void updateOneNode(const GlobalValue *Callee, FunctionInfo &FS);
   void updateOneNode(const GlobalValue *Callee) {
     updateOneNode(Callee, Functions.find(Callee)->second);
   }
   void updateAllNodes() {
     for (auto &F : Functions)
       updateOneNode(F.first, F.second);
public:
   ConstantRange getArgumentAccessRange(const GlobalValue *Callee,
                                        unsigned ParamNo,
                                        const ConstantRange &Offsets) const;
 };
 
 ConstantRange StackSafetyDataFlowAnalysis::getArgumentAccessRange(
     const GlobalValue *Callee, unsigned ParamNo,
     const ConstantRange &Offsets) const {
-  auto IT = Functions.find(Callee);
+  auto FnIt = Functions.find(Callee);
   // Unknown callee (outside of LTO domain or an indirect call).
-  if (IT == Functions.end())
+  if (FnIt == Functions.end())
     return UnknownRange;
-  const FunctionInfo &FS = IT->second;
-  if (ParamNo >= FS.Params.size()) // possibly vararg
+  auto &FS = FnIt->second;
+  auto ParamIt = FS.Params.find(ParamNo);
+  if (ParamIt == FS.Params.end())
     return UnknownRange;
-  auto &Access = FS.Params[ParamNo].Range;
+  auto &Access = ParamIt->second.Range;
   if (Access.isEmptySet())
     return Access;
-  if (Access.isFullSet() || Offsets.isFullSet())
+  if (Access.isFullSet())
     return UnknownRange;
   if (Offsets.signedAddMayOverflow(Access) !=
       ConstantRange::OverflowResult::NeverOverflows)
     return UnknownRange;
   return Access.add(Offsets);
 }
 
 bool StackSafetyDataFlowAnalysis::updateOneUse(UseInfo &US,
bool StackSafetyDataFlowAnalysis::updateOneUse(UseInfo &US,
   }
   return Changed;
 }
 
 void StackSafetyDataFlowAnalysis::updateOneNode(const GlobalValue *Callee,
                                                 FunctionInfo &FS) {
   bool UpdateToFullSet = FS.UpdateCount > StackSafetyMaxIterations;
   bool Changed = false;
-  for (auto &PS : FS.Params)
-    Changed |= updateOneUse(PS, UpdateToFullSet);
+  for (auto &KV : FS.Params)
+    Changed |= updateOneUse(KV.second, UpdateToFullSet);
 
   if (Changed) {
     LLVM_DEBUG(dbgs() << "=== update [" << FS.UpdateCount
                       << (UpdateToFullSet ? ", full-set" : "") << "] " << &FS
                       << "\n");
     // Callers of this function may need updating.
     for (auto &CallerID : Callers[Callee])
       WorkList.insert(CallerID);
 
     ++FS.UpdateCount;
   }
 }
 
 void StackSafetyDataFlowAnalysis::runDataFlow() {
   Callers.clear();
   WorkList.clear();
 
   SmallVector<const GlobalValue *, 16> Callees;
   for (auto &F : Functions) {
     Callees.clear();
-    FunctionInfo &FS = F.second;
-    for (auto &PS : FS.Params)
-      for (auto &CS : PS.Calls)
+    for (auto &KV : F.second.Params)
+      for (auto &CS : KV.second.Calls)
         Callees.push_back(CS.Callee);
 
     llvm::sort(Callees);
     Callees.erase(std::unique(Callees.begin(), Callees.end()), Callees.end());
 
     for (auto &Callee : Callees)
       Callers[Callee].push_back(F.first);
   }
if (F) {
       C.Callee = F;
       continue;
     }
 
     return Use.updateRange(FullSet);
   }
 }
 
-void resolveAllCalls(SmallVectorImpl<UseInfo> &Values) {
-  for (auto &V : Values)
-    resolveAllCalls(V);
-}
-
 GVToSSI createGlobalStackSafetyInfo(
     std::map<const GlobalValue *, FunctionInfo> Functions) {
   GVToSSI SSI;
   if (Functions.empty())
     return SSI;
 
   // FIXME: Simplify printing and remove copying here.
   auto Copy = Functions;
 
-  for (auto &FI : Copy)
-    resolveAllCalls(FI.second.Params);
+  for (auto &FnKV : Copy)
+    for (auto &KV : FnKV.second.Params)
+      resolveAllCalls(KV.second);
 
   uint32_t PointerSize = Copy.begin()
                              ->first->getParent()
                              ->getDataLayout()
                              .getMaxPointerSizeInBits();
   StackSafetyDataFlowAnalysis SSDFA(PointerSize, std::move(Copy));
 
   for (auto &F : SSDFA.run()) {
     auto FI = F.second;
     auto &SrcF = Functions[F.first];
     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.find(KV.first)->second.Calls;
     }
-    size_t Pos = 0;
-    for (auto &P : FI.Params) {
-      P.Calls = SrcF.Params[Pos].Calls;
-      ++Pos;
+    for (auto &KV : FI.Params) {
+      auto &P = KV.second;
+      P.Calls = SrcF.Params.find(KV.first)->second.Calls;
     }
     SSI[F.first] = std::move(FI);
   }
 
   return SSI;
 }
 
 } // end anonymous namespace

llvm/test/Analysis/StackSafetyAnalysis/ipa.ll

entry:
   ret void
 }
 
 define i32 @TestRecursiveNoOffset(i32* %p, i32 %size) {
 ; CHECK-LABEL: @TestRecursiveNoOffset dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
 ; LOCAL-NEXT: p[]: empty-set, @RecursiveNoOffset(arg0, [0,1)){{$}}
 ; GLOBAL-NEXT: p[]: full-set, @RecursiveNoOffset(arg0, [0,1)){{$}}
-; CHECK-NEXT: size[]: empty-set, @RecursiveNoOffset(arg1, [0,1)){{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: sum[4]: [0,4), @RecursiveNoOffset(arg2, [0,1)){{$}}
 ; CHECK-NOT: ]:
 entry:
   %sum = alloca i32, align 4
   %0 = bitcast i32* %sum to i8*
   store i32 0, i32* %sum, align 4
   call void @RecursiveNoOffset(i32* %p, i32 %size, i32* %sum)
   %1 = load i32, i32* %sum, align 4
   ret i32 %1
 }
 
 define void @TestRecursiveWithOffset(i32 %size) {
 ; CHECK-LABEL: @TestRecursiveWithOffset dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: size[]: empty-set, @RecursiveWithOffset(arg0, [0,1)){{$}}
 ; CHECK-NEXT: allocas uses:
 ; LOCAL-NEXT: sum[64]: empty-set, @RecursiveWithOffset(arg1, [0,1)){{$}}
 ; GLOBAL-NEXT: sum[64]: full-set, @RecursiveWithOffset(arg1, [0,1)){{$}}
 ; CHECK-NOT: ]:
 entry:
   %sum = alloca i32, i64 16, align 4
   call void @RecursiveWithOffset(i32 %size, i32* %sum)
   ret void

 ; GLOBAL-NEXT: p[]: [-2,2), @Rec1(arg0, [-5,-4)){{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NOT: ]:
 
 ; CHECK-LABEL: @RecursiveNoOffset{{$}}
 ; CHECK-NEXT: args uses:
 ; LOCAL-NEXT: p[]: [0,4), @RecursiveNoOffset(arg0, [4,5)){{$}}
 ; GLOBAL-NEXT: p[]: full-set, @RecursiveNoOffset(arg0, [4,5)){{$}}
-; CHECK-NEXT: size[]: empty-set, @RecursiveNoOffset(arg1, [-1,0)){{$}}
 ; CHECK-NEXT: acc[]: [0,4), @RecursiveNoOffset(arg2, [0,1)){{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NOT: ]:
 
 ; CHECK-LABEL: @RecursiveWithOffset{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: size[]: empty-set, @RecursiveWithOffset(arg0, [-1,0)){{$}}
 ; LOCAL-NEXT: acc[]: [0,4), @RecursiveWithOffset(arg1, [4,5)){{$}}
 ; GLOBAL-NEXT: acc[]: full-set, @RecursiveWithOffset(arg1, [4,5)){{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NOT: ]:

llvm/test/Analysis/StackSafetyAnalysis/local.ll

entry:
   %x1 = bitcast i32* %x to i8*
   call void %p(i8* %x1);
   ret void
 }
 
 define void @NonConstantOffset(i1 zeroext %z) {
 ; CHECK-LABEL: @NonConstantOffset dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: z[]: full-set{{$}}
 ; CHECK-NEXT: allocas uses:
 ; FIXME: SCEV can't look through selects.
 ; CHECK-NEXT: x[4]: [-4,4){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca i32, align 4
   %x1 = bitcast i32* %x to i8*
   %idx = select i1 %z, i64 1, i64 2
entry:
   %x2 = getelementptr i32, i32* %x, i64 -400000000000
   store i32 0, i32* %x2, align 1
   ret void
 }
 
 define void @PossiblyNegativeOffset(i16 %z) {
 ; CHECK-LABEL: @PossiblyNegativeOffset dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: z[]: full-set
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x[40]: [-131072,131072){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca i32, i32 10, align 4
   %x2 = getelementptr i32, i32* %x, i16 %z
   store i32 0, i32* %x2, align 1
   ret void
 }
 
 define void @NonConstantOffsetOOB(i1 zeroext %z) {
 ; CHECK-LABEL: @NonConstantOffsetOOB dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: z[]: full-set{{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x[4]: [-8,8){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca i32, align 4
   %x1 = bitcast i32* %x to i8*
   %idx = select i1 %z, i64 1, i64 4
   %x2 = getelementptr i8, i8* %x1, i64 %idx
entry:
   %x3 = bitcast i8* %x2 to i32*
   store i32 0, i32* %x3, align 1
   ret void
 }
 
 define void @DynamicAllocaUnused(i64 %size) {
 ; CHECK-LABEL: @DynamicAllocaUnused dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: size[]: empty-set{{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x[0]: empty-set{{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca i32, i64 %size, align 16
   ret void
 }
 
 ; Dynamic alloca with unknown size.
 define void @DynamicAlloca(i64 %size) {
 ; CHECK-LABEL: @DynamicAlloca dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: size[]: [-9223372036854775808,9223372036854775796){{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x[0]: [0,4){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca i32, i64 %size, align 16
   store i32 0, i32* %x, align 1
   ret void
 }
 
 ; Dynamic alloca with limited size.
 ; FIXME: could be proved safe. Implement.
 define void @DynamicAllocaFiniteSizeRange(i1 zeroext %z) {
 ; CHECK-LABEL: @DynamicAllocaFiniteSizeRange dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: z[]: [-9223372036854775808,9223372036854775796){{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x[0]: [0,4){{$}}
 ; CHECK-NOT: ]:
 entry:
   %size = select i1 %z, i64 3, i64 5
   %x = alloca i32, i64 %size, align 16
   store i32 0, i32* %x, align 1
   ret void

 
 for.cond.cleanup:
   ret i8 %add
 }
 
 define dso_local void @SizeCheck(i32 %sz) {
 ; CHECK-LABEL: @SizeCheck{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: sz[]: empty-set{{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x1[128]: [0,4294967295){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x1 = alloca [128 x i8], align 16
   %x1.sub = getelementptr inbounds [128 x i8], [128 x i8]* %x1, i64 0, i64 0
   %cmp = icmp slt i32 %sz, 129
   br i1 %cmp, label %if.then, label %if.end
 
 if.then:
   call void @llvm.memset.p0i8.i32(i8* nonnull align 16 %x1.sub, i8 0, i32 %sz, i1 false)
   br label %if.end
 
 if.end:
   ret void
 }
 
 ; FIXME: scalable allocas are considered to be of size zero, and scalable accesses to be full-range.
 ; This effectively disables safety analysis for scalable allocations.
 define void @Scalable(<vscale x 4 x i32>* %p, <vscale x 4 x i32>* %unused, <vscale x 4 x i32> %v) {
 ; CHECK-LABEL: @Scalable dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
 ; CHECK-NEXT:   p[]: full-set
 ; CHECK-NEXT:   unused[]: empty-set
-; CHECK-NEXT:   v[]: full-set
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT:   x[0]: [0,1){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca <vscale x 4 x i32>, align 4
   %x1 = bitcast <vscale x 4 x i32>* %x to i8*
   store i8 0, i8* %x1, align 1
   store <vscale x 4 x i32> %v, <vscale x 4 x i32>* %p, align 4

llvm/test/Analysis/StackSafetyAnalysis/memintrin.ll

entry:
   %x1 = bitcast i32* %x to i8*
   call void @llvm.memset.p0i8.i32(i8* %x1, i8 42, i32 5, i1 false)
   ret void
 }
 
 define void @MemsetNonConst(i32 %size) {
 ; CHECK-LABEL: MemsetNonConst dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: size[]: empty-set{{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x[4]: [0,4294967295){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca i32, align 4
   %x1 = bitcast i32* %x to i8*
   call void @llvm.memset.p0i8.i32(i8* %x1, i8 42, i32 %size, i1 false)
   ret void
 }
 
 ; FIXME: memintrinsics should look at size range when possible
 ; Right now we refuse any non-constant size.
 define void @MemsetNonConstInBounds(i1 zeroext %z) {
 ; CHECK-LABEL: MemsetNonConstInBounds dso_preemptable{{$}}
 ; CHECK-NEXT: args uses:
-; CHECK-NEXT: z[]: empty-set{{$}}
 ; CHECK-NEXT: allocas uses:
 ; CHECK-NEXT: x[4]: [0,4294967295){{$}}
 ; CHECK-NOT: ]:
 entry:
   %x = alloca i32, align 4
   %x1 = bitcast i32* %x to i8*
   %size = select i1 %z, i32 3, i32 4
   call void @llvm.memset.p0i8.i32(i8* %x1, i8 42, i32 %size, i1 false)