[SanitizerCoverage] Add fallback DebugLocation for instrumented calls

[jkl]

Summary

When building the kernel with LTO, KCOV & debug information enabled,
multiple inlinable SanitizerCoverage functions require debug information
present.

In such cases we repurpose the InstrumentationIRBuilder that ensures
the necessary debug information is added if necessary.

This has been done analogous to the work for the ThreadSanitizer
in D124937. (I added reviewers based on that, feel free to ignore or add more if not relevant).

This has already been discussed a bit here: https://github.com/ClangBuiltLinux/linux/issues/1721

[melver]

llvm/test/Instrumentation/SanitizerCoverage/missing_dbg.ll

6

Is sanitize_address needed for this test?

[jkl]

llvm/test/Instrumentation/SanitizerCoverage/missing_dbg.ll

6

oh, no. It's just a leftover from copying the other test. LKM if I should send an update or if you just want to fix it when committing

[melver]

llvm/test/Instrumentation/SanitizerCoverage/missing_dbg.ll

6

I assume it's trivial to fix, so just fixing it before committing is fine.

6

Oh, do you have commit access, or should I commit it?

[jkl]

llvm/test/Instrumentation/SanitizerCoverage/missing_dbg.ll

6

No I don't, so you can just go ahead with it. Thanks!

llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp

 // CacheSize is encoded in the name of the run-time function.
 void ModuleSanitizerCoverage::InjectCoverageForIndirectCalls(
     Function &F, ArrayRef<Instruction *> IndirCalls) {
   if (IndirCalls.empty())
     return;
   assert(Options.TracePC || Options.TracePCGuard ||
          Options.Inline8bitCounters || Options.InlineBoolFlag);
   for (auto *I : IndirCalls) {
-    IRBuilder<> IRB(I);
+    InstrumentationIRBuilder IRB(I);
     CallBase &CB = cast<CallBase>(*I);
     Value *Callee = CB.getCalledOperand();
     if (isa<InlineAsm>(Callee))
       continue;
     IRB.CreateCall(SanCovTracePCIndir, IRB.CreatePointerCast(Callee, IntptrTy));
   }
 }
 
 // For every switch statement we insert a call:
 // __sanitizer_cov_trace_switch(CondValue,
 //      {NumCases, ValueSizeInBits, Case0Value, Case1Value, Case2Value, ... })
 
 void ModuleSanitizerCoverage::InjectTraceForSwitch(
     Function &, ArrayRef<Instruction *> SwitchTraceTargets) {
   for (auto *I : SwitchTraceTargets) {
     if (SwitchInst *SI = dyn_cast<SwitchInst>(I)) {
-      IRBuilder<> IRB(I);
+      InstrumentationIRBuilder IRB(I);
       SmallVector<Constant *, 16> Initializers;
       Value *Cond = SI->getCondition();
       if (Cond->getType()->getScalarSizeInBits() >
           Int64Ty->getScalarSizeInBits())
         continue;
       Initializers.push_back(ConstantInt::get(Int64Ty, SI->getNumCases()));
       Initializers.push_back(
           ConstantInt::get(Int64Ty, Cond->getType()->getScalarSizeInBits()));
if (SwitchInst *SI = dyn_cast<SwitchInst>(I)) {
                      {Cond, IRB.CreatePointerCast(GV, Int64PtrTy)});
     }
   }
 }
 
 void ModuleSanitizerCoverage::InjectTraceForDiv(
     Function &, ArrayRef<BinaryOperator *> DivTraceTargets) {
   for (auto *BO : DivTraceTargets) {
-    IRBuilder<> IRB(BO);
+    InstrumentationIRBuilder IRB(BO);
     Value *A1 = BO->getOperand(1);
     if (isa<ConstantInt>(A1)) continue;
     if (!A1->getType()->isIntegerTy())
       continue;
     uint64_t TypeSize = DL->getTypeStoreSizeInBits(A1->getType());
     int CallbackIdx = TypeSize == 32 ? 0 :
         TypeSize == 64 ? 1 : -1;
     if (CallbackIdx < 0) continue;
     auto Ty = Type::getIntNTy(*C, TypeSize);
     IRB.CreateCall(SanCovTraceDivFunction[CallbackIdx],
                    {IRB.CreateIntCast(A1, Ty, true)});
   }
 }
 
 void ModuleSanitizerCoverage::InjectTraceForGep(
     Function &, ArrayRef<GetElementPtrInst *> GepTraceTargets) {
   for (auto *GEP : GepTraceTargets) {
-    IRBuilder<> IRB(GEP);
+    InstrumentationIRBuilder IRB(GEP);
     for (Use &Idx : GEP->indices())
       if (!isa<ConstantInt>(Idx) && Idx->getType()->isIntegerTy())
         IRB.CreateCall(SanCovTraceGepFunction,
                        {IRB.CreateIntCast(Idx, IntptrTy, true)});
   }
 }
 
 void ModuleSanitizerCoverage::InjectTraceForLoadsAndStores(
     Function &, ArrayRef<LoadInst *> Loads, ArrayRef<StoreInst *> Stores) {
   auto CallbackIdx = [&](Type *ElementTy) -> int {
     uint64_t TypeSize = DL->getTypeStoreSizeInBits(ElementTy);
     return TypeSize == 8     ? 0
            : TypeSize == 16  ? 1
            : TypeSize == 32  ? 2
            : TypeSize == 64  ? 3
            : TypeSize == 128 ? 4
                              : -1;
   };
   Type *PointerType[5] = {Int8PtrTy, Int16PtrTy, Int32PtrTy, Int64PtrTy,
                           Int128PtrTy};
   for (auto *LI : Loads) {
-    IRBuilder<> IRB(LI);
+    InstrumentationIRBuilder IRB(LI);
     auto Ptr = LI->getPointerOperand();
     int Idx = CallbackIdx(LI->getType());
     if (Idx < 0)
       continue;
     IRB.CreateCall(SanCovLoadFunction[Idx],
                    IRB.CreatePointerCast(Ptr, PointerType[Idx]));
   }
   for (auto *SI : Stores) {
-    IRBuilder<> IRB(SI);
+    InstrumentationIRBuilder IRB(SI);
     auto Ptr = SI->getPointerOperand();
     int Idx = CallbackIdx(SI->getValueOperand()->getType());
     if (Idx < 0)
       continue;
     IRB.CreateCall(SanCovStoreFunction[Idx],
                    IRB.CreatePointerCast(Ptr, PointerType[Idx]));
   }
 }
 
 void ModuleSanitizerCoverage::InjectTraceForCmp(
     Function &, ArrayRef<Instruction *> CmpTraceTargets) {
   for (auto *I : CmpTraceTargets) {
     if (ICmpInst *ICMP = dyn_cast<ICmpInst>(I)) {
-      IRBuilder<> IRB(ICMP);
+      InstrumentationIRBuilder IRB(ICMP);
       Value *A0 = ICMP->getOperand(0);
       Value *A1 = ICMP->getOperand(1);
       if (!A0->getType()->isIntegerTy())
         continue;
       uint64_t TypeSize = DL->getTypeStoreSizeInBits(A0->getType());
       int CallbackIdx = TypeSize == 8 ? 0 :
                         TypeSize == 16 ? 1 :
                         TypeSize == 32 ? 2 :

llvm/test/Instrumentation/SanitizerCoverage/missing_dbg.ll

+; RUN: opt < %s -passes='module(sancov-module)' -sanitizer-coverage-level=2 -S | FileCheck %s
+
+target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
+
+define i32 @with_dbg(ptr %a, ptr %b) !dbg !3 {
+entry:
+  %tmp1 = load i32, ptr %a, align 4
+  %cmp = icmp eq i32 %tmp1, 42
+  br i1 %cmp, label %0, label %1
+0:
+  store i32 %tmp1, ptr %b
+  br label %1
+1:
+  ret i32 %tmp1
+}
+; CHECK-LABEL: @with_dbg
+; CHECK-NEXT:  entry:
+; CHECK:       call void @__sanitizer_cov_trace_pc_guard(ptr @__sancov_gen_) #1, !dbg [[DBG1:![0-9]+]]
+; CHECK:       call void @__sanitizer_cov_trace_pc_guard(ptr inttoptr (i64 add (i64 ptrtoint (ptr @__sancov_gen_ to i64), i64 4) to ptr)) #1, !dbg [[DBG2:![0-9]+]]
+
+define i32 @without_dbg(ptr %a, ptr %b) {
+entry:
+  %tmp1 = load i32, ptr %a, align 4
+  %cmp = icmp eq i32 %tmp1, 42
+  br i1 %cmp, label %0, label %1
+0:
+  store i32 %tmp1, ptr %b
+  br label %1
+1:
+  ret i32 %tmp1
+}
+; CHECK-LABEL: @without_dbg
+; CHECK-NEXT:  entry:
+; CHECK:       call void @__sanitizer_cov_trace_pc_guard(ptr @__sancov_gen_.1) #1
+; CHECK:       call void @__sanitizer_cov_trace_pc_guard(ptr inttoptr (i64 add (i64 ptrtoint (ptr @__sancov_gen_.1 to i64), i64 4) to ptr)) #1
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C89, file: !1, producer: "", isOptimized: true, runtimeVersion: 0, emissionKind: LineTablesOnly, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "foo.c", directory: "")
+!2 = !{i32 2, !"Debug Info Version", i32 3}
+!3 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 190, type: !4, scopeLine: 192, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !0)
+!4 = !DISubroutineType(types: !5)
+!5 = !{}
+!6 = !DILocation(line: 192, scope: !3)
+!7 = !DILocation(line: 0, scope: !3)
+
+; CHECK:       [[DBG1]] = !DILocation(line: 192, scope: !3)
+; CHECK:       [[DBG2]] = !DILocation(line: 0, scope: !3)