[StackSafety] Skip non-pointer parameters

[vitalybuka]

Summary

Depends on D80908.

[eugenis]

LGTM

llvm/lib/Analysis/StackSafetyAnalysis.cpp

if (auto *AI = dyn_cast<AllocaInst>(&I)) {
       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();
+    if (A.getType()->isPointerTy())
       analyzeAllUses(&A, PS);
+    else
+      PS.updateRange(UnknownRange);
   }
 
   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);

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: size[]: full-set{{$}}
 ; 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: size[]: full-set{{$}}
 ; 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: size[]: full-set{{$}}
 ; 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)){{$}}
+; CHECK-NEXT: size[]: full-set{{$}}
 ; 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:
   %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: size[]: full-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: size[]: full-set{{$}}
 ; 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: z[]: full-set{{$}}
 ; 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: sz[]: full-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

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: size[]: full-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: z[]: full-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)

llvm/test/Bitcode/thinlto-function-summary-stacksafety.ll

 ; BC-NEXT: <PERMODULE
 ; DIS-DAG: = gv: (name: "NoParam", summaries: {{.*}} guid = 10287433468618421703
 define void @NoParam() #0 {
 entry:
   ret void
 }
 
 ; SSI-LABEL: function 'IntParam'
-; SSI: x[]: empty-set
-; BC-NEXT: <STACK_SAFETY_PARAMS op0=0 op1=0 op2=0 op3=0/>
 ; BC-NEXT: <PERMODULE
-; DIS-DAG: = gv: (name: "IntParam", summaries: {{.*}} params: ((param: 0, offset: [0, -1]))))) ; guid = 13164714711077064397
+; DIS-DAG: = gv: (name: "IntParam", summaries: {{.*}} guid = 13164714711077064397
 define void @IntParam(i32 %x) #0 {
 entry:
   ret void
 }
 
 ; SSI-LABEL: for function 'WriteNone'
 ; SSI: p[]: empty-set
 ; BC-NEXT: <STACK_SAFETY_PARAMS op0=0 op1=0 op2=0 op3=0/>
entry:
   %p1 = getelementptr i8, i8* %p, i64 -715
   call void @Callee(i8* %p1)
   ret void
 }
 
 ; BC-NEXT: <PERMODULE
 ; SSI-LABEL: for function 'CallAnyOffset'
 ; SSI: p[]: empty-set, @Callee(arg0, full-set)
-; SSI: i[]: empty-set, @Callee(arg0, full-set)
 ; DIS-DAG: = gv: (name: "CallAnyOffset", summaries: {{.*}} calls: ((callee: ^{{.*}}))))) ; guid = 4179978066780831873
 define void @CallAnyOffset(i8* %p, i64 %i) #0 {
 entry:
   %p1 = getelementptr i8, i8* %p, i64 %i
   call void @Callee(i8* %p1)
   ret void
 }