Addressing review comments.

[jlegare]

Summary

Eliminated the (newly introduced) llvm::Function argument
of ShouldInstrumentFunction() and used CurFuncDecl instead.

Added in file name based exclusions, as the change had apparently
been left out of my previous submission.

[jlegare]

This was not supposed to be committed.

clang/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(llvm::Function *F);
+  bool ShouldInstrumentFunction();
 
   /// ShouldSkipSanitizerInstrumentation - Return true if the current function
   /// should not be instrumented with sanitizers.
   bool ShouldSkipSanitizerInstrumentation();
 
   /// ShouldXRayInstrument - Return true if the current function should be
   /// instrumented with XRay nop sleds.
   bool ShouldXRayInstrumentFunction() const;

clang/lib/CodeGen/CodeGenFunction.cpp

 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/FPEnv.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Operator.h"
if (HasCleanups) {
     }
 
     PopCleanupBlocks(PrologueCleanupDepth);
   }
 
   // Emit function epilog (to return).
   llvm::DebugLoc Loc = EmitReturnBlock();
 
-  if (ShouldInstrumentFunction(CurFn)) {
+  if (ShouldInstrumentFunction()) {
     if (CGM.getCodeGenOpts().InstrumentFunctions)
       CurFn->addFnAttr("instrument-function-exit", "__cyg_profile_func_exit");
     if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
       CurFn->addFnAttr("instrument-function-exit-inlined",
                        "__cyg_profile_func_exit");
   }
 
   // Emit debug descriptor for function end.
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(llvm::Function *F) {
+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)
+      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 FName(F->getName());
+  std::string MangledName(CurFn->getName());
+  std::string DemangledName(llvm::demangle(MangledName));
   for (ExcludedFunctionIterator ExcludedFunction = ExcludedFunctions.begin(),
-                                Sentinel = ExcludedFunctions.end();
-       ExcludedFunction != Sentinel; ++ExcludedFunction) {
-    if (FName.find(*ExcludedFunction) != std::string::npos)
+       ExcludedFunction != Sentinel; ++ExcludedFunction)
+    if (DemangledName.find(*ExcludedFunction) != std::string::npos)
       return false;
-  }
 
   return true;
 }
 
 bool CodeGenFunction::ShouldSkipSanitizerInstrumentation() {
   if (!CurFuncDecl)
     return false;
   return CurFuncDecl->hasAttr<DisableSanitizerInstrumentationAttr>();
if (CGDebugInfo *DI = getDebugInfo()) {
     // Reconstruct the type from the argument list so that implicit parameters,
     // such as 'this' and 'vtt', show up in the debug info. Preserve the calling
     // convention.
     DI->emitFunctionStart(GD, Loc, StartLoc,
                           DI->getFunctionType(FD, RetTy, Args), CurFn,
                           CurFuncIsThunk);
   }
 
-  if (ShouldInstrumentFunction(CurFn)) {
+  if (ShouldInstrumentFunction()) {
     if (CGM.getCodeGenOpts().InstrumentFunctions)
       CurFn->addFnAttr("instrument-function-entry", "__cyg_profile_func_enter");
     if (CGM.getCodeGenOpts().InstrumentFunctionsAfterInlining)
       CurFn->addFnAttr("instrument-function-entry-inlined",
                        "__cyg_profile_func_enter");
     if (CGM.getCodeGenOpts().InstrumentFunctionEntryBare)
       CurFn->addFnAttr("instrument-function-entry-inlined",
                        "__cyg_profile_func_enter_bare");