[clang][CodeGen] add fn_ret_thunk_extern to synthetic fns

[nickdesaulniers]

Summary

Follow up fix to
commit 2240d72f15f3 ("[X86] initial -mfunction-return=thunk-extern
support")
https://reviews.llvm.org/D129572

@nathanchance reported that -mfunction-return=thunk-extern was failing
to annotate the asan and tsan contructors.
https://lore.kernel.org/llvm/[e-mail]-3990X/

I then noticed the same occurring for gcov synthetic functions.

Similar to
commit 2786e67 ("[IR][sanitizer] Add module flag "frame-pointer" and set
it for cc1 -mframe-pointer={non-leaf,all}")
define a new module level MetaData, "fn_ret_thunk_extern", then when set
adds the fn_ret_thunk_extern IR Fn Attr to synthetically created
Functions.

Fixes https://github.com/llvm/llvm-project/issues/56514

[nickdesaulniers]

clang/test/CodeGen/attr-function-return.c

108

https://lore.kernel.org/llvm/[e-mail]-3990X/ also mentions asan.module_dtor(). I wonder what flags produce that?

[nathanchance]

This cleans up the objtool warnings I initially reported and does not introduce any other regressions in my Linux kernel build and QEMU boot tests.

[nickdesaulniers]

• rebase on top of D129691

[MaskRay]

https://github.com/llvm/llvm-project/issues/56514

Fixes #56514

Just use Fixes https://github.com/llvm/llvm-project/issues/56514 or Fixes #56514. GitHub can close the issue automatically.

clang/test/CodeGen/attr-function-return.c

9

I feel that having 3 RUN lines is excessive. Since we already have a test that asan/tsan/gcov respect getModuleFlag, it is not necessary for a new one to duplicate all the combinations.

llvm/docs/LangRef.rst

7372

keep the list sorted

[MaskRay]

llvm/lib/IR/Function.cpp

357

How about "function_return_thunk_extern"? fn doesn't abbreviate much. Having the function_return substring makes it easy for grepping.

[nickdesaulniers]

• rename md idententifier, sort langref

[nickdesaulniers]

Thanks for the review!

clang/test/CodeGen/attr-function-return.c

9

All three have caused problems for us; I'd prefer to retain each.

llvm/lib/IR/Function.cpp

357

Done, but note that this was done to match the Function Attribute.

[nickdesaulniers]

• resort langref, oops

[MaskRay]

clang/test/CodeGen/attr-function-return.c

9

Having asan/tsan may invite others to add more sanitizer tests to this not-so-related file. I can step back and think that gcov/asan are sufficient.

[nickdesaulniers]

clang/test/CodeGen/attr-function-return.c

9

If such sanitizers produce synthetic functions, we should add them to this file.

[MaskRay]

clang/test/CodeGen/attr-function-return.c

9

No. The sanitizers should pick a dedicated test file and be added there, if the use case is important enough.

Today we have -mfunction-return=thunk-extern, tomorrow we can have -mfoobar. We should not add {-mfunction-return=thunk-extern,-mfoobar} * {-fsanitize=address,-fsanitize=thread,...} for every combination.

clang/lib/CodeGen/CodeGenModule.cpp

if (CodeGenOpts.CFProtectionBranch &&
     // Indicate that we want to instrument branch control flow protection.
     getModule().addModuleFlag(llvm::Module::Override, "cf-protection-branch",
                               1);
   }
 
   if (CodeGenOpts.IBTSeal)
     getModule().addModuleFlag(llvm::Module::Override, "ibt-seal", 1);
 
+  if (CodeGenOpts.FunctionReturnThunks)
+    getModule().addModuleFlag(llvm::Module::Override, "function_return_thunk_extern", 1);
+
   // Add module metadata for return address signing (ignoring
   // non-leaf/all) and stack tagging. These are actually turned on by function
   // attributes, but we use module metadata to emit build attributes. This is
   // needed for LTO, where the function attributes are inside bitcode
   // serialised into a global variable by the time build attributes are
   // emitted, so we can't access them. LTO objects could be compiled with
   // different flags therefore module flags are set to "Min" behavior to achieve
   // the same end result of the normal build where e.g BTI is off if any object

clang/test/CodeGen/attr-function-return.c

 // RUN: %clang_cc1 -std=gnu2x -triple x86_64-linux-gnu %s -emit-llvm -o - \
 // RUN:   -Werror=ignored-attributes \
 // RUN:   | FileCheck %s --check-prefixes=CHECK,CHECK-NOM
 // RUN: %clang_cc1 -std=gnu2x -triple x86_64-linux-gnu %s -emit-llvm -o - \
 // RUN:   -Werror=ignored-attributes -mfunction-return=keep \
 // RUN:   | FileCheck %s --check-prefixes=CHECK,CHECK-KEEP
 // RUN: %clang_cc1 -std=gnu2x -triple x86_64-linux-gnu %s -emit-llvm -o - \
 // RUN:   -Werror=ignored-attributes -mfunction-return=thunk-extern \
 // RUN:   | FileCheck %s --check-prefixes=CHECK,CHECK-EXTERN
+// RUN: %clang_cc1 -std=gnu2x -triple x86_64-linux-gnu %s -emit-llvm -o - \
+// RUN:  -mfunction-return=thunk-extern -fprofile-arcs \
+// RUN:   | FileCheck %s --check-prefix=CHECK-GCOV
+// RUN: %clang_cc1 -std=gnu2x -triple x86_64-linux-gnu %s -emit-llvm -o - \
+// RUN:  -mfunction-return=thunk-extern -fsanitize=address \
+// RUN:   | FileCheck %s --check-prefix=CHECK-ASAN
+// RUN: %clang_cc1 -std=gnu2x -triple x86_64-linux-gnu %s -emit-llvm -o - \
+// RUN:  -mfunction-return=thunk-extern -fsanitize=thread \
+// RUN:   | FileCheck %s --check-prefix=CHECK-TSAN
 
 #if !__has_attribute(function_return)
 #error "missing attribute support for function_return"
 #endif
 
 // CHECK: @keep() [[KEEP:#[0-9]+]]
 __attribute__((function_return("keep"))) void keep(void) {}
 

 // When there is no -mfunction-return= flag set (NOM) or it's set to keep,
 // we don't emit anything into the IR for unattributed functions.
 
 // CHECK-NOM:    @no_attrs() [[NOATTR:#[0-9]+]]
 // CHECK-KEEP:   @no_attrs() [[NOATTR:#[0-9]+]]
 // CHECK-EXTERN: @no_attrs() [[EXTERN]]
 void no_attrs(void) {}
 
+// Test synthetic functions.
+// CHECK-GCOV: @__llvm_gcov_writeout() unnamed_addr [[EXTERNGCOV:#[0-9]+]]
+// CHECK-GCOV: @__llvm_gcov_reset() unnamed_addr [[EXTERNGCOV]]
+// CHECK-GCOV: @__llvm_gcov_init() unnamed_addr [[EXTERNGCOV]]
+// CHECK-ASAN: @asan.module_ctor() [[EXTERNASAN:#[0-9]+]]
+// CHECK-TSAN: @tsan.module_ctor() [[EXTERNTSAN:#[0-9]+]]
+
 // CHECK-NOM-NOT:  [[NOATTR]] = {{.*}}fn_ret_thunk_extern
 // CHECK-KEEP-NOT: [[NOATTR]] = {{.*}}fn_ret_thunk_extern
 // CHECK: [[EXTERN]] = {{.*}}fn_ret_thunk_extern
+// CHECK-GCOV: [[EXTERNGCOV]] = {{.*}}fn_ret_thunk_extern
+// CHECK-ASAN: [[EXTERNASAN]] = {{.*}}fn_ret_thunk_extern
+// CHECK-TSAN: [[EXTERNTSAN]] = {{.*}}fn_ret_thunk_extern

llvm/docs/LangRef.rst

 These metadata correspond to a few function attributes with significant code
 generation behaviors. Function attributes with just optimization purposes
 should not be listed because the performance impact of these synthesized
 functions is small.
 
 - "frame-pointer": **Max**. The value can be 0, 1, or 2. A synthesized function
   will get the "frame-pointer" function attribute, with value being "none",
   "non-leaf", or "all", respectively.
+- "function_return_thunk_extern": The synthesized function will get the
+  ``fn_return_thunk_extern`` function attribute.
 - "uwtable": **Max**. The value can be 0, 1, or 2. If the value is 1, a synthesized
   function will get the ``uwtable(sync)`` function attribute, if the value is 2,
   a synthesized function will get the ``uwtable(async)`` function attribute.
 
 Objective-C Garbage Collection Module Flags Metadata
 ----------------------------------------------------
 
 On the Mach-O platform, Objective-C stores metadata about garbage
 collection in a special section called "image info". The metadata
 consists of a version number and a bitmask specifying what types of
 garbage collection are supported (if any) by the file. If two or more
 modules are linked together their garbage collection metadata needs to

llvm/lib/IR/Function.cpp

case FramePointerKind::None:
     break;
   case FramePointerKind::NonLeaf:
     B.addAttribute("frame-pointer", "non-leaf");
     break;
   case FramePointerKind::All:
     B.addAttribute("frame-pointer", "all");
     break;
   }
+  if (M->getModuleFlag("function_return_thunk_extern"))
+    B.addAttribute(Attribute::FnRetThunkExtern);
   F->addFnAttrs(B);
   return F;
 }
 
 void Function::removeFromParent() {
   getParent()->getFunctionList().remove(getIterator());
 }