[gcov] Set nounwind and respect module flags metadata "frame-pointer" & "uwtable" for synthesized functions

[MaskRay]

Summary

This applies the D100251 mechanism to the gcov instrumentation pass.

With this patch, -fno-omit-frame-pointer in
clang -fprofile-arcs -O1 -fno-omit-frame-pointer will be respected for synthesized
__llvm_gcov_writeout,__llvm_gcov_reset,__llvm_gcov_init functions: the frame pointer
will be kept (note: on many targets -O1 eliminates the frame pointer by default).

clang -fno-exceptions -fno-asynchronous-unwind-tables -g -fprofile-arcs will
produce .debug_frame instead of .eh_frame.

Fix: https://github.com/ClangBuiltLinux/linux/issues/955

[MaskRay]

llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp

1048

I think not all three functions need noinline, so I do not place noinline in the common function.

@void Do you know why noredzone is needed? Many other instrumentation passes don't set this attribute.

[nickdesaulniers]

Thanks @MaskRay !

llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp

1048

With KCOV (not GCOV) and LTO, we can and sometimes do inline the coverage runtime helper functions, FWIW.

[void]

llvm/lib/Transforms/Instrumentation/GCOVProfiling.cpp

1048

It's been 8 years... Here's the commit where I added it

commit 74f334e476a62d0ddcd4751d266560a503e00d55
Author: Bill Wendling <[e-mail]>
Date:   Mon Dec 10 19:46:49 2012 +0000

    Don't use a red zone for code coverage if the user specified `-mno-red-zone'.

    The `-mno-red-zone' flag wasn't being propagated to the functions that code
    coverage generates. This allowed some of them to use the red zone when that
    wasn't allowed.
    <rdar://problem/12843084>

    llvm-svn: 169754

[MaskRay]

Move NoRedZone to the common function

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);
   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);
 
for (unsigned i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
     if (EmitGCDA) {
       emitGlobalConstructor(CountersBySP);
       EmitGCDA = false;
     }
   }
   return true;
 }
 
+Function *GCOVProfiler::createInternalFunction(FunctionType *FTy,
+                                               StringRef Name) {
+  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);
+  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_flush" function to be executed
+  // 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 = Function::Create(FTy, GlobalValue::InternalLinkage,
-                                 "__llvm_gcov_init", M);
-  F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
-  F->setLinkage(GlobalValue::InternalLinkage);
+  Function *F = createInternalFunction(FTy, "__llvm_gcov_init");
   F->addFnAttr(Attribute::NoInline);
-  if (Options.NoRedZone)
-    F->addFnAttr(Attribute::NoRedZone);
 
   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 = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage,
-                                 "__llvm_gcov_writeout", M);
-  WriteoutF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
+    WriteoutF = createInternalFunction(WriteoutFTy, "__llvm_gcov_writeout");
   WriteoutF->addFnAttr(Attribute::NoInline);
-  if (Options.NoRedZone)
-    WriteoutF->addFnAttr(Attribute::NoRedZone);
 
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF);
   IRBuilder<> Builder(BB);
 
   auto *TLI = &GetTLI(*WriteoutF);
 
   FunctionCallee StartFile = getStartFileFunc(TLI);
   FunctionCallee EmitFunction = getEmitFunctionFunc(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 = Function::Create(FTy, GlobalValue::InternalLinkage,
-                              "__llvm_gcov_reset", M);
-  ResetF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
+    ResetF = createInternalFunction(FTy, "__llvm_gcov_reset");
   ResetF->addFnAttr(Attribute::NoInline);
-  if (Options.NoRedZone)
-    ResetF->addFnAttr(Attribute::NoRedZone);
 
   BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", ResetF);
   IRBuilder<> Builder(Entry);
 
   // Zero out the counters.
   for (const auto &I : CountersBySP) {
     GlobalVariable *GV = I.first;
     Constant *Null = Constant::getNullValue(GV->getValueType());

llvm/test/Transforms/GCOVProfiling/function-numbering.ll

 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.10.0"
 
 ; GCDA: @__llvm_internal_gcov_emit_function_args.0 = internal unnamed_addr constant
 ; GCDA-SAME: { i32 0,
 ; GCDA-SAME: { i32 1,
 ;
-; GCDA-LABEL: define internal void @__llvm_gcov_writeout() {{.*}} {
+; GCDA-LABEL: define internal void @__llvm_gcov_writeout() unnamed_addr #[[#ATTR:]] {
 ; GCDA-NEXT:  entry:
 ; GCDA-NEXT:    br label %[[FILE_LOOP_HEADER:.*]]
 ;
 ; GCDA:       [[FILE_LOOP_HEADER]]:
 ; GCDA-NEXT:    %[[IV:.*]] = phi i32 [ 0, %entry ], [ %[[NEXT_IV:.*]], %[[FILE_LOOP_LATCH:.*]] ]
 ; GCDA-NEXT:    %[[FILE_INFO:.*]] = getelementptr inbounds {{.*}}, {{.*}}* @__llvm_internal_gcov_emit_file_info, i32 0, i32 %[[IV]]
 ; GCDA-NEXT:    %[[START_FILE_ARGS:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[FILE_INFO]], i32 0, i32 0
 ; GCDA-NEXT:    %[[START_FILE_ARG_0_PTR:.*]] = getelementptr inbounds {{.*}}, {{.*}}* %[[START_FILE_ARGS]], i32 0, i32 0
define void @bar() !dbg !7 {
   ; This function is referenced by the debug info, but no lines have locations.
   ret void
 }
 
 define void @baz() !dbg !8 {
   ret void, !dbg !13
 }
 
+; GCDA: attributes #[[#ATTR]] = { noinline nounwind }
+
 !llvm.gcov = !{!14}
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!9, !10}
 !llvm.ident = !{!11}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.6.0 ", isOptimized: false, emissionKind: LineTablesOnly, file: !1, enums: !2, retainedTypes: !2, globals: !2, imports: !2)
 !1 = !DIFile(filename: ".../llvm/test/Transforms/GCOVProfiling/function-numbering.ll", directory: "")
 !2 = !{}

llvm/test/Transforms/GCOVProfiling/module-flags.ll

+; RUN: mkdir -p %t && cd %t
+; RUN: opt < %s -S -passes=insert-gcov-profiling | FileCheck %s
+
+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, !10}
+
+!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)
+
+;; Due to -fasynchronous-unwind-tables.
+!9 = !{i32 7, !"uwtable", i32 1}
+
+;; Due to -fno-omit-frame-pointer.
+!10 = !{i32 7, !"frame-pointer", i32 2}
+
+;; Infer uwtable and "frame-pointer" from the module flags.
+; CHECK: define internal void @__llvm_gcov_writeout() unnamed_addr #[[#ATTR:]]
+; CHECK: define internal void @__llvm_gcov_reset() unnamed_addr #[[#ATTR]]
+; CHECK: define internal void @__llvm_gcov_init() unnamed_addr #[[#ATTR]]
+; CHECK: attributes #[[#ATTR]] = { noinline nounwind uwtable "frame-pointer"="all" }