Added command-line options to exclude functions from function instrumentation output.

[jlegare]

Summary

Two options have been added: -finstrument-functions-exclude-function-list and -finstrument-functions-exclude-file-list.
The first can be used to exclude functions by name, and the second can be used to exclude a function by the
file name where its definition occurs. Both options take a comma-separated list of values as their argument. By-name
exclusion is done on the demangled name.

[jhenderson]

I'm not sure why I've been added as a reviewer, as I don't develop or review things within clang...

[jlegare]

@jhenderson Apologies, I'm new to the process here.

[jhenderson]

In D130161#3665527, @jlegare wrote:

@jhenderson Apologies, I'm new to the process here.

Usually, you should look at who has recently modified the touched files, or reviewed those same files, and add them as reviewers. Often, it's a good idea to add several people as reviewers at once, since not everybody has the time to review everything. You should also look to see if there's a code owner for the impacted code. There is some documentation on finding reviewers here: https://llvm.org/docs/Phabricator.html#finding-potential-reviewers.

[hans]

Can you share the motivation for this? There's already an attribute to exclude functions from this instrumentation.

clang/lib/CodeGen/CodeGenFunction.cpp

526

Why do we need the new F parameter? Doesn't CurFuncDecl work?

556

This seems a rather imprecise match. What is ExcludedFunction is "foo" and we have a function "football", should it be excluded?

Also the description says the demangled name is used (which seemed odd) but I don't see any demangling taking place?

[jlegare]

@jhenderson Thanks for the information, I appreciate it.

@hans Thank you for the comments. I'll be looking to address them later.

[jlegare]

@hans However, to answer your question: the user may not be in a position to change the source where the troublesome functions are located, in order to add the attribute.

[jlegare]

Addressing review comments.

• Dropped argument to ShouldInstrumentFunction().
• Added file name based exclusion, which had accidentally been left out of previous commit.
• Added demangler.
• Applied git clang-format.

[jlegare]

@hans To address your concern about loose matching: I went with this approach because it fit my use-case. Do you think that an exact match would be more appropriate?

[jlegare]

I appear to have butchered something in trying to apply a patch. I will revisit and resubmit later when I've straightened things out.

[MaskRay]

See https://clang.llvm.org/docs/SanitizerSpecialCaseList.html , -fsanitize-ignorelist and *san_ignorelist.txt in the Clang resource directory.
If you can state your motivation, I am happy to implement it as I just modified related code for sanitizers.

clang/lib/CodeGen/CodeGenFunction.cpp

if (RetAlloca && RetAlloca->use_empty()) {
       RetAlloca->eraseFromParent();
       ReturnValue = Address::invalid();
     }
   }
 }
 
 /// ShouldInstrumentFunction - Return true if the current function should be
 /// instrumented with __cyg_profile_func_* calls
 bool CodeGenFunction::ShouldInstrumentFunction() {
   if (!CGM.getCodeGenOpts().InstrumentFunctions &&
       !CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining &&
       !CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
     return false;
   if (!CurFuncDecl || CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>())
     return false;
 
   // Downcast to a function declaration and check to see if the current function
   // is inlined.  If it is inlined but not externally-visible, then don't
   // generate tracing for it: at link-time, the function will be gone and the
   // first argument to the __cyg_profile_* function will be unresolvable.
   const FunctionDecl *FDecl = dyn_cast<FunctionDecl>(CurFuncDecl);
-  if (FDecl &&
-      FDecl->isInlined() &&
+  if (FDecl && FDecl->isInlined() &&
       !FDecl->isInlineDefinitionExternallyVisible())
     return false;
 
   // The list of excluded file name substrings specified on the command line
   // is searched to see if any of them is a substring the current function's
   // declaration location.
   static std::map<SourceLocation, std::string> CachedFilePaths;
   SourceLocation DeclarationLocation = CurFuncDecl->getLocation();
 
   // If the declaration location doesn't correspond directly to a file, it
   // can't be excluded based file name.
   if (DeclarationLocation.isFileID()) {
     if (CachedFilePaths.find(DeclarationLocation) == CachedFilePaths.end()) {
       ASTContext &Context = CurFuncDecl->getASTContext();
       const SourceManager &SM = Context.getSourceManager();
 
       PresumedLoc PresumedLocation = SM.getPresumedLoc(DeclarationLocation);
       CachedFilePaths[DeclarationLocation] = PresumedLocation.getFilename();
     }
 
     std::string Path = CachedFilePaths[DeclarationLocation];
 
     typedef std::vector<std::string>::const_iterator ExcludedPathIterator;
 
     const std::vector<std::string> &ExcludedPaths =
         CGM.getCodeGenOpts().InstrumentFunctionsExcludedPaths;
 
     for (ExcludedPathIterator ExcludedPath = ExcludedPaths.begin(),
-           Sentinel = ExcludedPaths.end(); ExcludedPath != Sentinel; ++ExcludedPath)
+                              Sentinel = ExcludedPaths.end();
+         ExcludedPath != Sentinel; ++ExcludedPath)
       if (Path.find(*ExcludedPath) != std::string::npos)
         return false;
   }
 
   typedef std::vector<std::string>::const_iterator ExcludedFunctionIterator;
 
   // The list of excluded function name substrings specified on the command-line
   // is searched to see if any of them is a substring of our (current) function
   // name.
   const std::vector<std::string> &ExcludedFunctions =
       CGM.getCodeGenOpts().InstrumentFunctionsExcludedFunctions;
 
   std::string MangledName(CurFn->getName());
   std::string DemangledName(llvm::demangle(MangledName));
   for (ExcludedFunctionIterator ExcludedFunction = ExcludedFunctions.begin(),
                                 Sentinel = ExcludedFunctions.end();
        ExcludedFunction != Sentinel; ++ExcludedFunction)
     if (DemangledName.find(*ExcludedFunction) != std::string::npos)
       return false;
 
   return true;
 }
 
 bool CodeGenFunction::ShouldSkipSanitizerInstrumentation() {