[GCOV] Set !kcfi_type metadata for indirectly called functions

[samitolvanen]

Summary

With CONFIG_GCOV_KERNEL, the Linux kernel indirectly calls the
__llvm_gcov_* functions generated by LLVM. With -fsanitize=kcfi,
these calls are made from instrumented code and fail indirect
call checks as they don't have !kcfi_type metadata. Similarly
to D138945, set type metadata for these functions to allow GCOV
and KCFI to be both enabled.

Link: https://github.com/ClangBuiltLinux/linux/issues/1778

[MaskRay]

Ensuring that every instrumentation works with kcfi is a lot of work on the compiler side (think that another instrumentation technique comes up, we need to update O(n) existing instrumentation passes) and I don't quite agree that it's compiler's responsibility.
But if sanitizers and gcov are all, I think it's fine...

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

45

Used

llvm/test/Transforms/GCOVProfiling/kcfi.ll

26

This comment should be moved to the top.

[samitolvanen]

Addressed comments.

[samitolvanen]

In D141444#4042006, @MaskRay wrote:

Ensuring that every instrumentation works with kcfi is a lot of work on the compiler side (think that another instrumentation technique comes up, we need to update O(n) existing instrumentation passes) and I don't quite agree that it's compiler's responsibility.
But if sanitizers and gcov are all, I think it's fine...

I agree, and yes, ASAN and GCOV are the only uses of global constructors in Linux.

[MaskRay]

LGTM.

llvm/test/Transforms/GCOVProfiling/kcfi.ll

1

4

Line one would be better. (I know that many tests place the comment after all RUN lines.)

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

 /// https://llvm.org/docs/LangRef.html#the-llvm-global-ctors-global-variable
 void appendToGlobalCtors(Module &M, Function *F, int Priority,
                          Constant *Data = nullptr);
 
 /// Same as appendToGlobalCtors(), but for global dtors.
 void appendToGlobalDtors(Module &M, Function *F, int Priority,
                          Constant *Data = nullptr);
 
+/// Sets the KCFI type for the function. Used for compiler-generated functions
+/// that are indirectly called in instrumented code.
+void setKCFIType(Module &M, Function &F, StringRef MangledType);
+
 FunctionCallee declareSanitizerInitFunction(Module &M, StringRef InitName,
                                             ArrayRef<Type *> InitArgTypes);
 
 /// Creates sanitizer constructor function.
 /// \return Returns pointer to constructor.
 Function *createSanitizerCtor(Module &M, StringRef CtorName);
 
 /// Creates sanitizer constructor function, and calls sanitizer's init

llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp

 private:
   // Create the .gcno files for the Module based on DebugInfo.
   bool
   emitProfileNotes(NamedMDNode *CUNode, bool HasExecOrFork,
                    function_ref<BlockFrequencyInfo *(Function &F)> GetBFI,
                    function_ref<BranchProbabilityInfo *(Function &F)> GetBPI,
                    function_ref<const TargetLibraryInfo &(Function &F)> GetTLI);
 
-  Function *createInternalFunction(FunctionType *FTy, StringRef Name);
+  Function *createInternalFunction(FunctionType *FTy, StringRef Name,
+                                   StringRef MangledType = "");
   void emitGlobalConstructor(
       SmallVectorImpl<std::pair<GlobalVariable *, MDNode *>> &CountersBySP);
 
   bool isFunctionInstrumented(const Function &F);
   std::vector<Regex> createRegexesFromString(StringRef RegexesStr);
   static bool doesFilenameMatchARegex(StringRef Filename,
                                       std::vector<Regex> &Regexes);
 
if (EmitGCDA) {
       emitGlobalConstructor(CountersBySP);
       EmitGCDA = false;
     }
   }
   return true;
 }
 
 Function *GCOVProfiler::createInternalFunction(FunctionType *FTy,
-                                               StringRef Name) {
+                                               StringRef Name,
+                                               StringRef MangledType /*=""*/) {
   Function *F = Function::createWithDefaultAttr(
       FTy, GlobalValue::InternalLinkage, 0, Name, M);
   F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   F->addFnAttr(Attribute::NoUnwind);
   if (Options.NoRedZone)
     F->addFnAttr(Attribute::NoRedZone);
+  if (!MangledType.empty())
+    setKCFIType(*M, *F, MangledType);
   return F;
 }
 
 void GCOVProfiler::emitGlobalConstructor(
     SmallVectorImpl<std::pair<GlobalVariable *, MDNode *>> &CountersBySP) {
   Function *WriteoutF = insertCounterWriteout(CountersBySP);
   Function *ResetF = insertReset(CountersBySP);
 
   // Create a small bit of code that registers the "__llvm_gcov_writeout" to
   // be executed at exit and the "__llvm_gcov_reset" function to be executed
   // when "__gcov_flush" is called.
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
-  Function *F = createInternalFunction(FTy, "__llvm_gcov_init");
+  Function *F = createInternalFunction(FTy, "__llvm_gcov_init", "_ZTSFvvE");
   F->addFnAttr(Attribute::NoInline);
 
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F);
   IRBuilder<> Builder(BB);
 
   FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   auto *PFTy = PointerType::get(FTy, 0);
   FTy = FunctionType::get(Builder.getVoidTy(), {PFTy, PFTy}, false);
FunctionCallee GCOVProfiler::getEndFileFunc() {
   return M->getOrInsertFunction("llvm_gcda_end_file", FTy);
 }
 
 Function *GCOVProfiler::insertCounterWriteout(
     ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
   FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
   if (!WriteoutF)
-    WriteoutF = createInternalFunction(WriteoutFTy, "__llvm_gcov_writeout");
+    WriteoutF =
+        createInternalFunction(WriteoutFTy, "__llvm_gcov_writeout", "_ZTSFvvE");
   WriteoutF->addFnAttr(Attribute::NoInline);
 
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF);
   IRBuilder<> Builder(BB);
 
   auto *TLI = &GetTLI(*WriteoutF);
 
   FunctionCallee StartFile = getStartFileFunc(TLI);
Function *GCOVProfiler::insertCounterWriteout(
   return WriteoutF;
 }
 
 Function *GCOVProfiler::insertReset(
     ArrayRef<std::pair<GlobalVariable *, MDNode *>> CountersBySP) {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *ResetF = M->getFunction("__llvm_gcov_reset");
   if (!ResetF)
-    ResetF = createInternalFunction(FTy, "__llvm_gcov_reset");
+    ResetF = createInternalFunction(FTy, "__llvm_gcov_reset", "_ZTSFvvE");
   ResetF->addFnAttr(Attribute::NoInline);
 
   BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", ResetF);
   IRBuilder<> Builder(Entry);
   LLVMContext &C = Entry->getContext();
 
   // Zero out the counters.
   for (const auto &I : CountersBySP) {

llvm/lib/Transforms/Utils/ModuleUtils.cpp

 }
 
 void llvm::removeFromUsedLists(Module &M,
                                function_ref<bool(Constant *)> ShouldRemove) {
   removeFromUsedList(M, "llvm.used", ShouldRemove);
   removeFromUsedList(M, "llvm.compiler.used", ShouldRemove);
 }
 
-static void setKCFIType(Module &M, Function &F, StringRef MangledType) {
+void llvm::setKCFIType(Module &M, Function &F, StringRef MangledType) {
   if (!M.getModuleFlag("kcfi"))
     return;
   // Matches CodeGenModule::CreateKCFITypeId in Clang.
   LLVMContext &Ctx = M.getContext();
   MDBuilder MDB(Ctx);
   F.setMetadata(
       LLVMContext::MD_kcfi_type,
       MDNode::get(Ctx, MDB.createConstant(ConstantInt::get(

llvm/test/Transforms/GCOVProfiling/kcfi.ll

+; RUN: mkdir -p %t && cd %t
+; RUN: opt < %s -S -passes=insert-gcov-profiling | FileCheck %s
+
+;; Ensure __llvm_gcov_(writeout|reset|init) have !kcfi_type with KCFI.
+
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local void @empty() !dbg !5 {
+entry:
+  ret void, !dbg !8
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "a.c", directory: "")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 5}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = distinct !DISubprogram(name: "empty", scope: !1, file: !1, line: 1, type: !6, scopeLine: 1, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !2)
+!6 = !DISubroutineType(types: !7)
+!7 = !{null}
+!8 = !DILocation(line: 2, column: 1, scope: !5)
+!9 = !{i32 4, !"kcfi", i32 1}
+
+; CHECK: define internal void @__llvm_gcov_writeout()
+; CHECK-SAME: !kcfi_type
+; CHECK: define internal void @__llvm_gcov_reset()
+; CHECK-SAME: !kcfi_type
+; CHECK: define internal void @__llvm_gcov_init()
+; CHECK-SAME: !kcfi_type