[XRay][clang] Allow imbuing arg1 logging attribute via -fxray-always-instrument=

[dberris]

Summary

This change allows us to add arg1 logging support to functions through
the special case list provided through -fxray-always-instrument=. This
is useful for adding arg1 logging to functions that are either in
headers that users don't have control over (i.e. cannot change the
source) or would rather not do.

It only takes effect when the pattern is matched through the "fun:"
special case, as a category. As in:

fun:*pattern=arg1

[rnk]

lgtm

cfe/trunk/include/clang/Basic/XRayLists.h

public:
   XRayFunctionFilter(ArrayRef<std::string> AlwaysInstrumentPaths,
                      ArrayRef<std::string> NeverInstrumentPaths,
                      SourceManager &SM);
 
   enum class ImbueAttribute {
     NONE,
     ALWAYS,
     NEVER,
+    ALWAYS_ARG1,
   };
 
   ImbueAttribute shouldImbueFunction(StringRef FunctionName) const;
 
   ImbueAttribute
   shouldImbueFunctionsInFile(StringRef Filename,
                              StringRef Category = StringRef()) const;
 
   ImbueAttribute shouldImbueLocation(SourceLocation Loc,
                                      StringRef Category = StringRef()) const;
 };
 
 } // namespace clang
 
 #endif

cfe/trunk/lib/Basic/XRayLists.cpp

: AlwaysInstrument(
           llvm::SpecialCaseList::createOrDie(AlwaysInstrumentPaths)),
       NeverInstrument(llvm::SpecialCaseList::createOrDie(NeverInstrumentPaths)),
       SM(SM) {}
 
 XRayFunctionFilter::ImbueAttribute
 XRayFunctionFilter::shouldImbueFunction(StringRef FunctionName) const {
   // First apply the always instrument list, than if it isn't an "always" see
   // whether it's treated as a "never" instrument function.
+  if (AlwaysInstrument->inSection("fun", FunctionName, "arg1"))
+    return ImbueAttribute::ALWAYS_ARG1;
   if (AlwaysInstrument->inSection("fun", FunctionName))
     return ImbueAttribute::ALWAYS;
   if (NeverInstrument->inSection("fun", FunctionName))
     return ImbueAttribute::NEVER;
   return ImbueAttribute::NONE;
 }
 
 XRayFunctionFilter::ImbueAttribute

cfe/trunk/lib/CodeGen/CodeGenModule.cpp

bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
   if (Attr == ImbueAttr::NONE)
     Attr = XRayFilter.shouldImbueFunction(Fn->getName());
   switch (Attr) {
   case ImbueAttr::NONE:
     return false;
   case ImbueAttr::ALWAYS:
     Fn->addFnAttr("function-instrument", "xray-always");
     break;
+  case ImbueAttr::ALWAYS_ARG1:
+    Fn->addFnAttr("function-instrument", "xray-always");
+    Fn->addFnAttr("xray-log-args", "1");
+    break;
   case ImbueAttr::NEVER:
     Fn->addFnAttr("function-instrument", "xray-never");
     break;
   }
   return true;
 }
 
 bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {

cfe/trunk/test/CodeGen/xray-imbue-arg1.cpp

+// RUN: echo "fun:*arg1*=arg1" >> %t.always-instrument
+// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 -fxray-always-instrument=%t.always-instrument -emit-llvm -o - %s -triple x86_64-unknown-linux-gnu | FileCheck %s
+
+void foo() {}
+
+void arg1(void*) {}
+
+// CHECK: define void @_Z3foov() #[[FOO:[0-9]+]] {
+// CHECK: define void {{.*}}arg1{{.*}} #[[ALWAYSARG1:[0-9]+]] {
+
+// CHECK: attributes #[[FOO]] = {{.*}}
+// CHECK: attributes #[[ALWAYSARG1]] = {{.*}} "function-instrument"="xray-always" {{.*}} "xray-log-args"="1"