add support for -fno-instrument-functions and -finstrument-functions-exclude-{file,function}-list=<arg1,arg2,...> to match gcc options.

[choikwa]

Summary

Builds on previous Differential D2219

Changes include:

• Using unordered_map with SourceLocation.ID (raw encoding) as key
• Demangle only if !isExternC. Used dyn_cast<FunctionDecl>((Decl*)CurFuncDecl) for this
• Modified an existing C testcase to test for options.

[aaron.ballman]

lib/CodeGen/CodeGenFunction.cpp

425

This parameter can be const.

436

Can use const auto * here.

444

This static has me worried. Does this data need to be cached across codegen modules? If not, perhaps this variable can be hung onto the CodeGenModule instead?

The variable should be named Cache instead of cache. Also, is an unordered_map the correct data structure to use? Would a DenseMap make more sense because the keys and values are both small (PresumedLoc::getFilename() returns a const char * that I believe can be used).

447

key -> Key

449

ctx -> CTX, and I think this can be a const ref.

460–461

You can use a range-based for loop here instead, and then get rid of the typedef for CIt.

467

You can avoid the copy here by assigning to a StringRef instead.

472

status -> Status

473

result -> Result

486

Can use a range-based for loop here.

[choikwa]

addressed code review. made doc consistent with functionality.

[choikwa]

Forgot to hang Cache to CodeGenModule, will do that shortly

[choikwa]

renamed and moved Cache to SourceLocToFileNameMap in CodeGenModule

[hfinkel]

Please also add a C++ test to check the mangling-related features.

lib/CodeGen/CodeGenFunction.cpp

419

Using the system demangler here seems like the wrong solution. You have the current function declaration, CurFuncDecl, and from it you should be able to extract the full name.

I think that this will do it:

std::string FullFuncName = PredefinedExpr::ComputeName(
        PredefinedExpr::PrettyFunctionNoVirtual, CurFuncDecl);

lib/CodeGen/CodeGenModule.cpp

4601 ↗

(On Diff #114388)

Make this function inline in the class definition.

[choikwa]

Addressing Hal's feedback

[majnemer]

lib/CodeGen/CodeGenFunction.cpp

470

Is this comment still correct?

lib/CodeGen/CodeGenModule.h

503 ↗

(On Diff #117264)

Pointers lean right.

1212 ↗

(On Diff #117264)

inline is redundant here.

[choikwa]

• - Address formating feedback, remove redundant inline

[hfinkel]

test/CodeGenCXX/instrument-functions.cpp

8 ↗

(On Diff #117267)

I'm a bit confused about this test. Are you trying to match against the mangled names, or the demangled names, or both?

[choikwa]

• add comment to CPP test to explain usage

[hfinkel]

In D37624#885288, @choikwa wrote:

• add comment to CPP test to explain usage

Thanks. Please also add some tests showing matching overloaded functions, functions with template parameters, etc.

Do we need to strip whitespace before trying to match the demangled names?

[choikwa]

• add more CPP tests: func overload, template special

[majnemer]

lib/CodeGen/CodeGenFunction.cpp

462

Space after if.

480

Ditto.

[choikwa]

In D37624#885290, @hfinkel wrote:

In D37624#885288, @choikwa wrote:

• add comment to CPP test to explain usage

Thanks. Please also add some tests showing matching overloaded functions, functions with template parameters, etc.

Do we need to strip whitespace before trying to match the demangled names?

Some cursory testing with g++ shows that only the 'test5' of 'test5(float, int, int*)' is matched. 'test5(' or 'test5 (' is not matched. It seems weird that arguments are not matched.

g++ man page shows

"The function name to be matched is its user-visible name, such as "vector<int> blah(const vector<int> &)", not the internal mangled name"

but it doesn't seem to be including parameters.

Also uncovered a bug where sub argument list containing comma needs to be surrounded by single quote, but clang seems to ignores single quote.
I'll try to dig around ArgList implementation to see if it can return argument surrounded by single-quote as a whole.

test/CodeGenCXX/instrument-functions.cpp

8 ↗

(On Diff #117267)

It's matching demangled names, so Z5test3 would not match and insert instrumentation calls to test3(int). Since this wasn't clear, I will add comment in the test.

[hfinkel]

In D37624#885295, @choikwa wrote:

In D37624#885290, @hfinkel wrote:

In D37624#885288, @choikwa wrote:

• add comment to CPP test to explain usage

Thanks. Please also add some tests showing matching overloaded functions, functions with template parameters, etc.

Do we need to strip whitespace before trying to match the demangled names?

Some cursory testing with g++ shows that only the 'test5' of 'test5(float, int, int*)' is matched. 'test5(' or 'test5 (' is not matched. It seems weird that arguments are not matched.

g++ man page shows

"The function name to be matched is its user-visible name, such as "vector<int> blah(const vector<int> &)", not the internal mangled name"

but it doesn't seem to be including parameters.

Interesting. Can you tell what GCC is doing w.r.t. namespace names, class names, etc. and template parameters?

Also uncovered a bug where sub argument list containing comma needs to be surrounded by single quote, but clang seems to ignores single quote.
I'll try to dig around ArgList implementation to see if it can return argument surrounded by single-quote as a whole.

[choikwa]

In D37624#885308, @hfinkel wrote:

In D37624#885295, @choikwa wrote:

In D37624#885290, @hfinkel wrote:

In D37624#885288, @choikwa wrote:

• add comment to CPP test to explain usage

Thanks. Please also add some tests showing matching overloaded functions, functions with template parameters, etc.

Do we need to strip whitespace before trying to match the demangled names?

Some cursory testing with g++ shows that only the 'test5' of 'test5(float, int, int*)' is matched. 'test5(' or 'test5 (' is not matched. It seems weird that arguments are not matched.

g++ man page shows

"The function name to be matched is its user-visible name, such as "vector<int> blah(const vector<int> &)", not the internal mangled name"

but it doesn't seem to be including parameters.

Interesting. Can you tell what GCC is doing w.r.t. namespace names, class names, etc. and template parameters?

Also uncovered a bug where sub argument list containing comma needs to be surrounded by single quote, but clang seems to ignores single quote.
I'll try to dig around ArgList implementation to see if it can return argument surrounded by single-quote as a whole.

Given A::B::C<D>(T a), only 'C<D>' is meaningful in g++'s matcher. Adding anything else escapes the match [ 'B::C', 'C<D>(' ].
It seems like g++ will also not match single quotes as a whole, ie. int fooboo() is matched by 'foo,boo'.

[hfinkel]

In D37624#885311, @choikwa wrote:

In D37624#885308, @hfinkel wrote:

In D37624#885295, @choikwa wrote:

In D37624#885290, @hfinkel wrote:

In D37624#885288, @choikwa wrote:

• add comment to CPP test to explain usage

Thanks. Please also add some tests showing matching overloaded functions, functions with template parameters, etc.

Do we need to strip whitespace before trying to match the demangled names?

Some cursory testing with g++ shows that only the 'test5' of 'test5(float, int, int*)' is matched. 'test5(' or 'test5 (' is not matched. It seems weird that arguments are not matched.

g++ man page shows

"The function name to be matched is its user-visible name, such as "vector<int> blah(const vector<int> &)", not the internal mangled name"

but it doesn't seem to be including parameters.

Interesting. Can you tell what GCC is doing w.r.t. namespace names, class names, etc. and template parameters?

Also uncovered a bug where sub argument list containing comma needs to be surrounded by single quote, but clang seems to ignores single quote.
I'll try to dig around ArgList implementation to see if it can return argument surrounded by single-quote as a whole.

Given A::B::C<D>(T a), only 'C<D>' is meaningful in g++'s matcher. Adding anything else escapes the match [ 'B::C', 'C<D>(' ].
It seems like g++ will also not match single quotes as a whole, ie. int fooboo() is matched by 'foo,boo'.

Can you get more information on what GCC actually implemented and why? It's not clear to me that ignoring the namespaces is the most-useful way to do this. I don't want to emulate GCC bugs, but maybe there's a good reason why their implementation works this way.

[choikwa]

Can you get more information on what GCC actually implemented and why? It's not clear to me that ignoring the namespaces is the most-useful way to do this. I don't want to emulate GCC bugs, but maybe there's a good reason why their implementation works this way.

This is what I found, https://gcc.gnu.org/ml/gcc-patches/2015-12/msg00473.html
Diff shows it doesn't seem to specially treat single quotes.

+ case OPT_finstrument_functions_include_function_list_:
+ add_comma_separated_to_vector
+ (&opts->x_flag_instrument_functions_include_functions, arg);
+ break;

[hfinkel]

In D37624#885438, @choikwa wrote:

Can you get more information on what GCC actually implemented and why? It's not clear to me that ignoring the namespaces is the most-useful way to do this. I don't want to emulate GCC bugs, but maybe there's a good reason why their implementation works this way.

This is what I found, https://gcc.gnu.org/ml/gcc-patches/2015-12/msg00473.html

To state the obvious, that patch has zero C++ test cases. Can try emailing the author of the feature in GCC and try to get some clarity on what the intended behavior is on their end? I'm trying to figure out what's useful here. I think we do want to match namespaces.

Diff shows it doesn't seem to specially treat single quotes.

+ case OPT_finstrument_functions_include_function_list_:
+ add_comma_separated_to_vector
+ (&opts->x_flag_instrument_functions_include_functions, arg);
+ break;

[choikwa]

rebase to trunk

[apazos]

Hello folks, is there a plan to merge this feature still?

[hfinkel]

In D37624#1211748, @apazos wrote:

Hello folks, is there a plan to merge this feature still?

There's still a desire for the underlying functionality. We still need, as I recall, to figure out what's supposed to happen for C++ functions.

[oliverbrowne]

Hi Folks, don't know if this review is still active but I can provide some context on the GCC behavior with respect to namespaces, template params and function arguments, they were bugs, fixed in 2019.

Associated bug reports for namespace/class, and template parameter and argument mishandling:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90816
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90809

[hiraditya]

Is there a plan to revive this? this is quite necessary for one of my use cases.
can we at least have '-fno-instrument-functions'?

[paquette]

+1, someone just asked me if this feature exists and then found this patch. If this could be revived, I think it would help a lot of folks out. :)

[aaron.ballman]

In D37624#3838587, @paquette wrote:

+1, someone just asked me if this feature exists and then found this patch. If this could be revived, I think it would help a lot of folks out. :)

I took a quick pass over it and the changes look reasonable at a glance. If someone rebases this to trunk, I can look into it more thoroughly and rope in the other code owners.

docs/ClangCommandLineReference.rst

 .. option:: -fimplicit-module-maps, -fmodule-maps, -fno-implicit-module-maps
 
 Implicitly search the file system for module map files.
 
 .. option:: -fimplicit-modules, -fno-implicit-modules
 
 .. option:: -finput-charset=<arg>
 
-.. option:: -finstrument-functions
+.. option:: -finstrument-functions, -fno-instrument-functions, -finstrument-functions-exclude-file-list=<arg>, -finstrument-functions-exclude-function-list=<arg>
 
 Generate calls to instrument function entry and exit
 
 .. option:: -fintegrated-as, -fno-integrated-as, -integrated-as
 
 Enable the integrated assembler
 
 .. option:: -fjump-tables, -fno-jump-tables

include/clang/Driver/Options.td

 def finline_hint_functions: Flag<["-"], "finline-hint-functions">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Inline functions which are (explicitly or implicitly) marked inline">;
 def finline : Flag<["-"], "finline">, Group<clang_ignored_f_Group>;
 def fexperimental_new_pass_manager : Flag<["-"], "fexperimental-new-pass-manager">,
   Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Enables an experimental new pass manager in LLVM.">;
 def finput_charset_EQ : Joined<["-"], "finput-charset=">, Group<f_Group>;
 def fexec_charset_EQ : Joined<["-"], "fexec-charset=">, Group<f_Group>;
+
+def finstrument_functions_exclude_function_list : CommaJoined<["-"],
+  "finstrument-functions-exclude-function-list=">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Exclude given (mangled, if C++) functions from function instrumentation.">;
+def finstrument_functions_exclude_file_list : CommaJoined<["-"],
+  "finstrument-functions-exclude-file-list=">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Exclude given path segments from function instrumentation.">;
 def finstrument_functions : Flag<["-"], "finstrument-functions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Generate calls to instrument function entry and exit">;
+def fno_instrument_functions : Flag<["-"], "fno-instrument-functions">, Group<f_Group>,
+  HelpText<"Don't generate calls to instrument function entry and exit">;
 
 def fxray_instrument : Flag<["-"], "fxray-instrument">, Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Generate XRay instrumentation sleds on function entry and exit">;
 def fnoxray_instrument : Flag<["-"], "fno-xray-instrument">, Group<f_Group>,
   Flags<[CC1Option]>;
 
 def fxray_instruction_threshold_EQ :

include/clang/Frontend/CodeGenOptions.h

public:
   std::string TrapFuncName;
 
   /// A list of command-line options to forward to the LLVM backend.
   std::vector<std::string> BackendOptions;
 
   /// A list of dependent libraries.
   std::vector<std::string> DependentLibraries;
 
+  /// Functions to exclude from function instrumentation.
+  std::vector<std::string> InstrumentFunctionExclusionsFunctions;
+
+  /// Path segments to exclude from function instrumentation, eg, '/bits'
+  std::vector<std::string> InstrumentFunctionExclusionsPathSegments;
+
   /// A list of linker options to embed in the object file.
   std::vector<std::string> LinkerOptions;
 
   /// Name of the profile file to use as output for -fprofile-instr-generate
   /// and -fprofile-generate.
   std::string InstrProfileOutput;
 
   /// Name of the profile file to use with -fprofile-sample-use.

lib/CodeGen/CodeGenFunction.h

public:
   /// EnterDtorCleanups - Enter the cleanups necessary to complete the
   /// given phase of destruction for a destructor.  The end result
   /// should call destructors on members and base classes in reverse
   /// order of their construction.
   void EnterDtorCleanups(const CXXDestructorDecl *Dtor, CXXDtorType Type);
 
   /// ShouldInstrumentFunction - Return true if the current function should be
   /// instrumented with __cyg_profile_func_* calls
-  bool ShouldInstrumentFunction();
+  bool ShouldInstrumentFunction(llvm::Function *Fn);
 
   /// ShouldXRayInstrument - Return true if the current function should be
   /// instrumented with XRay nop sleds.
   bool ShouldXRayInstrumentFunction() const;
 
   /// EmitFunctionInstrumentation - Emit LLVM code to call the specified
   /// instrumentation function with the current function and the call site, if
   /// function instrumentation is enabled.

lib/CodeGen/CodeGenFunction.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Operator.h"
+#include <unordered_map>
 using namespace clang;
 using namespace CodeGen;
 
 /// shouldEmitLifetimeMarkers - Decide whether we need emit the life-time
 /// markers.
 static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts,
                                       const LangOptions &LangOpts) {
   if (CGOpts.DisableLifetimeMarkers)
if (CGDebugInfo *DI = getDebugInfo())
         DI->EmitLocation(Builder, EndLoc);
 
     PopCleanupBlocks(PrologueCleanupDepth);
   }
 
   // Emit function epilog (to return).
   llvm::DebugLoc Loc = EmitReturnBlock();
 
-  if (ShouldInstrumentFunction())
+  if (ShouldInstrumentFunction(CurFn))
     EmitFunctionInstrumentation("__cyg_profile_func_exit");
 
   // Emit debug descriptor for function end.
   if (CGDebugInfo *DI = getDebugInfo())
     DI->EmitFunctionEnd(Builder, CurFn);
 
   // Reset the debug location to that of the simple 'return' expression, if any
   // rather than that of the end of the function's scope '}'.
for (SmallVectorImpl<std::pair<llvm::Instruction *, llvm::Value *> >::iterator
            I = DeferredReplacements.begin(),
            E = DeferredReplacements.end();
        I != E; ++I) {
     I->first->replaceAllUsesWith(I->second);
     I->first->eraseFromParent();
   }
 }
 
+#if !defined(_MSC_VER)
+// Assume that __cxa_demangle is provided by libcxxabi (except for Windows).
+extern "C" char *__cxa_demangle(const char *mangled_name, char *output_buffer,
+                                size_t *length, int *status);
+#endif
+
 /// ShouldInstrumentFunction - Return true if the current function should be
 /// instrumented with __cyg_profile_func_* calls
-bool CodeGenFunction::ShouldInstrumentFunction() {
+bool CodeGenFunction::ShouldInstrumentFunction(llvm::Function *Fn) {
+  typedef std::vector<std::string>::const_iterator CIt;
   if (!CGM.getCodeGenOpts().InstrumentFunctions)
     return false;
   if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
     return false;
+
+  // Inline functions that are not externally visible mustn't be instrumented.
+  // They create a named reference to the inlined function, as the first
+  // parameter to __cyg_profile_* functions, which a linker will never be able
+  // to resolve.
+  const FunctionDecl *ActualFuncDecl = dyn_cast<FunctionDecl>(CurFuncDecl);
+  if (ActualFuncDecl &&
+      ActualFuncDecl->isInlined() &&
+      !ActualFuncDecl->isInlineDefinitionExternallyVisible()) {
+      return false;
+  }
+
+  SourceLocation SLoc = CurFuncDecl->getLocation();
+  static std::unordered_map<unsigned, std::string> cache;
+
+  if (SLoc.isFileID()) {
+    unsigned key = SLoc.getRawEncoding();
+    if (cache.find(key) == cache.end()) {
+      ASTContext &ctx = CurFuncDecl->getASTContext();
+      const SourceManager &SM = ctx.getSourceManager();
+
+      PresumedLoc PLoc = SM.getPresumedLoc(SLoc);
+      cache[key] = PLoc.getFilename();
+    }
+    std::string FunctionDeclPath = cache[key];
+
+    const std::vector<std::string> &PathSearch =
+      CGM.getCodeGenOpts().InstrumentFunctionExclusionsPathSegments;
+
+    for (CIt i = PathSearch.begin(), e = PathSearch.end(); i != e; ++i) {
+      if(FunctionDeclPath.find(*i) != std::string::npos) {
+        return false;
+      }
+    }
+  }
+
+  std::string FunctionName = Fn->getName();
+
+  // Skip demangling if decl is extern "C"
+#if !defined(_MSC_VER)
+  if (ActualFuncDecl && !ActualFuncDecl->isExternC()) {
+    int status = 0;
+    char *result = __cxa_demangle(FunctionName.c_str(), 0, 0, &status);
+
+    assert((status == 0 || status == -2) && "Couldn't demangle name.");
+
+    if (status == 0) {
+      FunctionName = result;
+      free(result);
+    }
+  }
+#endif
+
+  const std::vector<std::string> &FunctionSearch =
+    CGM.getCodeGenOpts().InstrumentFunctionExclusionsFunctions;
+  for (CIt i = FunctionSearch.begin(), e = FunctionSearch.end(); i != e; ++i) {
+    if(FunctionName.find(*i) != std::string::npos) {
+      return false;
+    }
+  }
+
   return true;
 }
 
 /// ShouldXRayInstrument - Return true if the current function should be
 /// instrumented with XRay nop sleds.
 bool CodeGenFunction::ShouldXRayInstrumentFunction() const {
   return CGM.getCodeGenOpts().XRayInstrumentFunctions;
 }
if (CGDebugInfo *DI = getDebugInfo()) {
     SmallVector<QualType, 16> ArgTypes;
     for (const VarDecl *VD : Args)
       ArgTypes.push_back(VD->getType());
     QualType FnType = getContext().getFunctionType(
         RetTy, ArgTypes, FunctionProtoType::ExtProtoInfo(CC));
     DI->EmitFunctionStart(GD, Loc, StartLoc, FnType, CurFn, Builder);
   }
 
-  if (ShouldInstrumentFunction())
+  if (ShouldInstrumentFunction(CurFn))
     EmitFunctionInstrumentation("__cyg_profile_func_enter");
 
   // Since emitting the mcount call here impacts optimizations such as function
   // inlining, we just add an attribute to insert a mcount call in backend.
   // The attribute "counting-function" is set to mcount function name which is
   // architecture dependent.
   if (CGM.getCodeGenOpts().InstrumentForProfiling) {
     if (CGM.getCodeGenOpts().CallFEntry)

lib/Driver/ToolChains/Clang.cpp

if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections,
                    UseSeparateSections)) {
     CmdArgs.push_back("-fdata-sections");
   }
 
   if (!Args.hasFlag(options::OPT_funique_section_names,
                     options::OPT_fno_unique_section_names, true))
     CmdArgs.push_back("-fno-unique-section-names");
 
+  if (Args.hasArg(options::OPT_finstrument_functions,
+                  options::OPT_fno_instrument_functions, false)) {
     Args.AddAllArgs(CmdArgs, options::OPT_finstrument_functions);
+    Args.AddAllArgs(CmdArgs,
+                    options::OPT_finstrument_functions_exclude_file_list);
+    Args.AddAllArgs(CmdArgs,
+                    options::OPT_finstrument_functions_exclude_function_list);
+  }
 
   addPGOAndCoverageFlags(C, D, Output, Args, CmdArgs);
 
   if (auto *ABICompatArg = Args.getLastArg(options::OPT_fclang_abi_compat_EQ))
     ABICompatArg->render(Args, CmdArgs);
 
   // Add runtime flag for PS4 when PGO or Coverage are enabled.
   if (RawTriple.isPS4CPU())

lib/Frontend/CompilerInvocation.cpp

for (const auto &A : Args) {
         // using \00 to seperate each commandline options.
         Opts.CmdArgs.push_back('\0');
       }
     }
   }
 
   Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
   Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
+  if (Opts.InstrumentFunctions) {
+    Opts.InstrumentFunctionExclusionsFunctions
+        = Args.getAllArgValues(OPT_finstrument_functions_exclude_function_list);
+    Opts.InstrumentFunctionExclusionsPathSegments
+        = Args.getAllArgValues(OPT_finstrument_functions_exclude_file_list);
+  }
   Opts.XRayInstrumentFunctions = Args.hasArg(OPT_fxray_instrument);
   Opts.XRayInstructionThreshold =
       getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
   Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
   Opts.CallFEntry = Args.hasArg(OPT_mfentry);
   Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
 
   if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,

test/CodeGen/instrument-functions.c

-// RUN: %clang_cc1 -S -debug-info-kind=standalone -emit-llvm -o - %s -finstrument-functions | FileCheck %s
+// RUN: %clang -S -emit-llvm -o - %s -finstrument-functions | FileCheck %s
+// RUN: %clang -S -emit-llvm -o - %s -fno-instrument-functions | FileCheck %s --check-prefix=NOINSTR
+
+// RUN: %clang -S -emit-llvm -o - %s -finstrument-functions -finstrument-functions-exclude-file-list=instrument | FileCheck %s --check-prefix=NOFILE
+// RUN: %clang -S -emit-llvm -o - %s -finstrument-functions -finstrument-functions-exclude-function-list=test3 | FileCheck %s --check-prefix=NOFUNC
 
 // CHECK: @test1
+// NOINSTR: @test1
+// NOFILE: @test1
+// NOFUNC: @test1
 int test1(int x) {
-// CHECK: call void @__cyg_profile_func_enter({{.*}}, !dbg
-// CHECK: call void @__cyg_profile_func_exit({{.*}}, !dbg
+// CHECK: __cyg_profile_func_enter
+// CHECK: __cyg_profile_func_exit
 // CHECK: ret
+// NOINSTR-NOT: __cyg_profile_func_enter
+// NOINSTR-NOT: __cyg_profile_func_exit
+// NOINSTR: ret
+// NOFILE-NOT: __cyg_profile_func_enter
+// NOFILE-NOT: __cyg_profile_func_exit
+// NOFILE: ret
+// NOFUNC: __cyg_profile_func_enter
+// NOFUNC: __cyg_profile_func_exit
+// NOFUNC: ret
   return x;
 }
 
 // CHECK: @test2
+// NOINSTR: @test2
+// NOFILE: @test2
+// NOFUNC: @test2
 int test2(int) __attribute__((no_instrument_function));
 int test2(int x) {
 // CHECK-NOT: __cyg_profile_func_enter
 // CHECK-NOT: __cyg_profile_func_exit
 // CHECK: ret
+// NOINSTR-NOT: __cyg_profile_func_enter
+// NOINSTR-NOT: __cyg_profile_func_exit
+// NOINSTR: ret
+// NOFILE-NOT: __cyg_profile_func_enter
+// NOFILE-NOT: __cyg_profile_func_exit
+// NOFILE: ret
+// NOFUNC-NOT: __cyg_profile_func_enter
+// NOFUNC-NOT: __cyg_profile_func_exit
+// NOFUNC: ret
+  return x;
+}
+
+// CHECK: @test3
+// NOINSTR: @test3
+// NOFILE: @test3
+// NOFUNC: @test3
+int test3(int x) {
+// CHECK: __cyg_profile_func_enter
+// CHECK: __cyg_profile_func_exit
+// CHECK: ret
+// NOINSTR-NOT: __cyg_profile_func_enter
+// NOINSTR-NOT: __cyg_profile_func_exit
+// NOINSTR: ret
+// NOFILE-NOT: __cyg_profile_func_enter
+// NOFILE-NOT: __cyg_profile_func_exit
+// NOFILE: ret
+// NOFUNC-NOT: __cyg_profile_func_enter
+// NOFUNC-NOT: __cyg_profile_func_exit
+// NOFUNC: ret
   return x;
 }