[XRay][clang] Add flag to choose instrumentation bundles

[dberris]

Summary

This change addresses http://llvm.org/PR36926 by allowing users to pick
which instrumentation bundles to use, when instrumenting with XRay. In
particular, the flag -fxray-instrumentation-bundle= has four valid
values:

• all: the default, emits all instrumentation kinds
• none: equivalent to -fnoxray-instrument
• function: emits the entry/exit instrumentation
• custom: emits the custom event instrumentation

These can be combined either as comma-separated values, or as
repeated flag values.

[echristo]

clang/include/clang/Frontend/CodeGenOptions.h

113

"function" might spell easier? :)

clang/lib/CodeGen/CGBuiltin.cpp

3264

I'd probably spell this code like the block above it rather than this.

clang/lib/Driver/XRayArgs.cpp

61

Extraneous reformat.

85

How about a more descriptive name here and a string switch below?

clang/lib/Frontend/CompilerInvocation.cpp

452

StringSwitch maybe?

[pelikan]

I would probably add more tests for the different configurations, but I suspect more diffs are coming after this.

clang/include/clang/Driver/Options.td

1112

I'd suggest making them "fn-only" and "custom-only", or just plain "function" and "custom".

1112

I also don't get why "none" is an option here, if it's equivalent to -fnoxray-instrument. Why duplicate the functionality and add more points the users will have to debug?

clang/include/clang/Frontend/CodeGenOptions.h

110

To me, this feels like a bitfield would be a better match.
All = Function | Custom
None = 0

clang/lib/Driver/XRayArgs.cpp

62

I would also print the triple. Something like:

"-fomit-bugs is not supported on target win64-ppc-none"

will be much more informative, especially when you collect logs from build machines on lots of architectures (like Linux distro/BSD package builders do).

85

+1

[dberris]

• fixup: address comments

clang/include/clang/Frontend/CodeGenOptions.h

110

Thought about that, but the ergonomics from the user-side isn't as good. Having to know about which kinds of sleds specifically to enable seems much harder to explain. Using bundles that we control from the beginning keeps this much simpler.

clang/lib/CodeGen/CGBuiltin.cpp

3264

The codegen options don't work like pointers, and we can't use C++17 if initialisers yet. Would have loved this to be:

if (auto XRayBundle = ...; XRayBundle == ... || XRayBundle == ...)
  return RValue::getIgnored();

Removed the scoping instead.

clang/lib/Driver/XRayArgs.cpp

62

Probably not today. Good idea though, could be a different patch.

[dberris]

• fixup: Fix tests for better coverage of settings

[echristo]

clang/include/clang/Frontend/CodeGenOptions.h

110

I dunno, I think I agree with the other commenter. This feels awkward.

clang/lib/CodeGen/CGBuiltin.cpp

3245

Break this out into some sort of function to determine which one we want? We do this a couple times.

[dberris]

• Rebase
• Address comments to use a bitmask/bitset for instrumentation bundle

[pelikan]

Most of my comments are minor enough I'd be OK if this went in. But please consider them before committing.

clang/include/clang/Driver/XRayArgs.h

25

Since the class already has "XRay" in its name, I would rename the member to just "InstrumentationBundle", just as most of the other members are.

clang/include/clang/Frontend/CodeGenOptions.h

110

Now I fail to spot where is this enum used. IIUC this should work even when it's not here, as the code uses the things in namespace XRayInstrKind.

clang/lib/CodeGen/CodeGenFunction.cpp

469

typo: builin -> builtin

471–474

I kind of don't like how the "-fxray-instrument" variable is called "XRayInstrumentFunctions" because that's not what it means any more. I think in a later diff, we should clean this up. Or maybe even clean up some of the old flags whose functionality has been superseded by this. But the logic here is fine.

Same with the misleading "ShouldXRayInstrumentFunction()" which controls custom events too, and not just functions.

clang/lib/Driver/XRayArgs.cpp

103–105

nitpick: I'd rewrite it to

if (!Valid) {
  D.Diag
  continue; // or break or return
}

<stuff if Valid below>

but the current code logic is fine.

clang/lib/Frontend/CompilerInvocation.cpp

456

did you mean: "(Mask == None)"?

[dberris]

• fixup: Address comments

[dberris]

Thanks, Martin! Landing now, after suggested changes.

clang/lib/CodeGen/CodeGenFunction.cpp

471–474

Good point. Yes, we could make this cleaner.

clang/include/clang/Driver/Options.td

def fxray_never_instrument :
   HelpText<"Filename defining the whitelist for imbuing the 'never instrument' XRay attribute.">;
 
 def fxray_always_emit_customevents : Flag<["-"], "fxray-always-emit-customevents">, Group<f_Group>,
   Flags<[CC1Option]>,
   HelpText<"Determine whether to always emit __xray_customevent(...) calls even if the function it appears in is not always instrumented.">;
 def fnoxray_always_emit_customevents : Flag<["-"], "fno-xray-always-emit-customevents">, Group<f_Group>,
   Flags<[CC1Option]>;
 
+def fxray_instrumentation_bundle : Joined<["-"], "fxray-instrumentation-bundle=">,
+  Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Select which bundle of XRay instrumentation points to emit. Options: all, none, function-extents, custom-only.">;
+
 def ffine_grained_bitfield_accesses : Flag<["-"],
   "ffine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Use separate accesses for bitfields with legal widths and alignments.">;
 def fno_fine_grained_bitfield_accesses : Flag<["-"],
   "fno-fine-grained-bitfield-accesses">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Use large-integer access for consecutive bitfield runs.">;
 
 def flat__namespace : Flag<["-"], "flat_namespace">;

clang/include/clang/Driver/XRayArgs.h

 namespace driver {
 
 class ToolChain;
 
 class XRayArgs {
   std::vector<std::string> AlwaysInstrumentFiles;
   std::vector<std::string> NeverInstrumentFiles;
   std::vector<std::string> ExtraDeps;
   bool XRayInstrument = false;
   int InstructionThreshold = 200;
   bool XRayAlwaysEmitCustomEvents = false;
+  std::string XRayBundle = "all";
 
 public:
   /// Parses the XRay arguments from an argument list.
   XRayArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
   void addArgs(const ToolChain &TC, const llvm::opt::ArgList &Args,
                llvm::opt::ArgStringList &CmdArgs, types::ID InputType) const;
 };
 
 } // namespace driver
 } // namespace clang
 
 #endif // LLVM_CLANG_DRIVER_XRAYARGS_H

clang/include/clang/Frontend/CodeGenOptions.h

public:
 
   enum EmbedBitcodeKind {
     Embed_Off,      // No embedded bitcode.
     Embed_All,      // Embed both bitcode and commandline in the output.
     Embed_Bitcode,  // Embed just the bitcode in the output.
     Embed_Marker    // Embed a marker as a placeholder for bitcode.
   };
 
+  enum XRayInstrumentationPointBundle {
+    XRay_All,        // Always emit all the instrumentation points.
+    XRay_None,       // Emit none of the instrumentation points.
+    XRay_Function,   // Only emit function entry/exit instrumentation
+                     // points.
+    XRay_CustomOnly, // Only emit custom event instrumentation points.
+  };
+
   /// The code model to use (-mcmodel).
   std::string CodeModel;
 
   /// The filename with path we use for coverage data files. The runtime
   /// allows further manipulation with the GCOV_PREFIX and GCOV_PREFIX_STRIP
   /// environment variables.
   std::string CoverageDataFile;
 

clang/include/clang/Frontend/CodeGenOptions.def

CODEGENOPT(CFProtectionBranch , 1, 0) ///< if -fcf-protection is
                                       ///< set to full or branch.
 CODEGENOPT(XRayInstrumentFunctions , 1, 0) ///< Set when -fxray-instrument is
                                            ///< enabled.
 CODEGENOPT(StackSizeSection  , 1, 0) ///< Set when -fstack-size-section is enabled.
 
 ///< Set when -fxray-always-emit-customevents is enabled.
 CODEGENOPT(XRayAlwaysEmitCustomEvents , 1, 0)
 
+///< Filter the instrumentation points we emit, to predefined groupings.
+ENUM_CODEGENOPT(XRayInstrumentationBundle, XRayInstrumentationPointBundle, 4,
+                XRayInstrumentationPointBundle::XRay_All)
+
 ///< Set the minimum number of instructions in a function to determine selective
 ///< XRay instrumentation.
 VALUE_CODEGENOPT(XRayInstructionThreshold , 32, 200)
 
 CODEGENOPT(InstrumentForProfiling , 1, 0) ///< Set when -pg is enabled.
 CODEGENOPT(CallFEntry , 1, 0) ///< Set when -mfentry is enabled.
 CODEGENOPT(LessPreciseFPMAD  , 1, 0) ///< Enable less precise MAD instructions to
                                      ///< be generated.

clang/lib/CodeGen/CGBuiltin.cpp

case Builtin::BI__builtin_os_log_format_buffer_size: {
     analyze_os_log::computeOSLogBufferLayout(CGM.getContext(), E, Layout);
     return RValue::get(ConstantInt::get(ConvertType(E->getType()),
                                         Layout.size().getQuantity()));
   }
 
   case Builtin::BI__xray_customevent: {
     if (!ShouldXRayInstrumentFunction())
       return RValue::getIgnored();
+
+    using XRayBundles = CodeGenOptions::XRayInstrumentationPointBundle;
+    auto Bundle = CGM.getCodeGenOpts().getXRayInstrumentationBundle();
+    switch (Bundle) {
+      case XRayBundles::XRay_None:
+      case XRayBundles::XRay_Function:
+        return RValue::getIgnored();
+      case XRayBundles::XRay_All:
         if (const auto *XRayAttr = CurFuncDecl->getAttr<XRayInstrumentAttr>())
           if (XRayAttr->neverXRayInstrument() && !AlwaysEmitXRayCustomEvents())
             return RValue::getIgnored();
+        LLVM_FALLTHROUGH;
+      case XRayBundles::XRay_CustomOnly:
+        break;
+    }
+    assert(Bundle == XRayBundles::XRay_All ||
+           Bundle == XRayBundles::XRay_CustomOnly);
 
     Function *F = CGM.getIntrinsic(Intrinsic::xray_customevent);
     auto FTy = F->getFunctionType();
     auto Arg0 = E->getArg(0);
     auto Arg0Val = EmitScalarExpr(Arg0);
     auto Arg0Ty = Arg0->getType();
     auto PTy0 = FTy->getParamType(0);
     if (PTy0 != Arg0Val->getType()) {
       if (Arg0Ty->isArrayType())
         Arg0Val = EmitArrayToPointerDecay(Arg0).getPointer();
       else
         Arg0Val = Builder.CreatePointerCast(Arg0Val, PTy0);

clang/lib/CodeGen/CodeGenFunction.cpp

 
 /// ShouldXRayInstrument - Return true if the current function should be
 /// instrumented with XRay nop sleds.
 bool CodeGenFunction::ShouldXRayInstrumentFunction() const {
   return CGM.getCodeGenOpts().XRayInstrumentFunctions;
 }
 
 /// AlwaysEmitXRayCustomEvents - Return true if we should emit IR for calls to
 /// the __xray_customevent(...) builin calls, when doing XRay instrumentation.
 bool CodeGenFunction::AlwaysEmitXRayCustomEvents() const {
-  return CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents;
+  return CGM.getCodeGenOpts().XRayInstrumentFunctions &&
+         (CGM.getCodeGenOpts().XRayAlwaysEmitCustomEvents ||
+          CGM.getCodeGenOpts().getXRayInstrumentationBundle() ==
+              CodeGenOptions::XRayInstrumentationPointBundle::XRay_CustomOnly);
 }
 
 llvm::Constant *
 CodeGenFunction::EncodeAddrForUseInPrologue(llvm::Function *F,
                                             llvm::Constant *Addr) {
   // Addresses stored in prologue data can't require run-time fixups and must
   // be PC-relative. Run-time fixups are undesirable because they necessitate
   // writable text segments, which are unsafe. And absolute addresses are
#undef SANITIZER
   if (D && SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
     if (matchesStlAllocatorFn(D, getContext()))
       SanOpts.Mask &= ~SanitizerKind::CFIUnrelatedCast;
   }
 
   // Apply xray attributes to the function (as a string, for now)
   bool InstrumentXray = ShouldXRayInstrumentFunction();
   if (D && InstrumentXray) {
+    using XRayBundles = CodeGenOptions::XRayInstrumentationPointBundle;
+    auto Bundle = CGM.getCodeGenOpts().getXRayInstrumentationBundle();
+    switch (Bundle) {
+    case XRayBundles::XRay_All:
+    case XRayBundles::XRay_Function:
       if (const auto *XRayAttr = D->getAttr<XRayInstrumentAttr>()) {
         if (XRayAttr->alwaysXRayInstrument())
           Fn->addFnAttr("function-instrument", "xray-always");
         if (XRayAttr->neverXRayInstrument())
           Fn->addFnAttr("function-instrument", "xray-never");
         if (const auto *LogArgs = D->getAttr<XRayLogArgsAttr>()) {
           Fn->addFnAttr("xray-log-args",
                         llvm::utostr(LogArgs->getArgumentCount()));
         }
       } else {
         if (!CGM.imbueXRayAttrs(Fn, Loc))
           Fn->addFnAttr(
               "xray-instruction-threshold",
               llvm::itostr(CGM.getCodeGenOpts().XRayInstructionThreshold));
       }
+      break;
+    case XRayBundles::XRay_None:
+    case XRayBundles::XRay_CustomOnly:
+      break;
+    }
   }
 
   // Add no-jump-tables value.
   Fn->addFnAttr("no-jump-tables",
                 llvm::toStringRef(CGM.getCodeGenOpts().NoUseJumpTables));
 
   // Add profile-sample-accurate value.
   if (CGM.getCodeGenOpts().ProfileSampleAccurate)

clang/lib/CodeGen/CodeGenModule.cpp

bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
   }
   return false;
 }
 
 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
                                    StringRef Category) const {
   if (!LangOpts.XRayInstrument)
     return false;
+
+  // Here, check whether the codegen options say we shouldn't be instrumenting
+  // functions.
+  using XRayBundles = CodeGenOptions::XRayInstrumentationPointBundle;
+  auto Bundle = CodeGenOpts.getXRayInstrumentationBundle();
+  switch (Bundle) {
+    case XRayBundles::XRay_None:
+    case XRayBundles::XRay_CustomOnly:
+      return true;
+    case XRayBundles::XRay_Function:
+    case XRayBundles::XRay_All:
+      break;
+  }
+
   const auto &XRayFilter = getContext().getXRayFilter();
   using ImbueAttr = XRayFunctionFilter::ImbueAttribute;
-  auto Attr = XRayFunctionFilter::ImbueAttribute::NONE;
+  auto Attr = ImbueAttr::NONE;
   if (Loc.isValid())
     Attr = XRayFilter.shouldImbueLocation(Loc, Category);
   if (Attr == ImbueAttr::NONE)
     Attr = XRayFilter.shouldImbueFunction(Fn->getName());
   switch (Attr) {
   case ImbueAttr::NONE:
     return false;
   case ImbueAttr::ALWAYS:

clang/lib/Driver/XRayArgs.cpp

 using namespace clang;
 using namespace clang::driver;
 using namespace llvm::opt;
 
 namespace {
 constexpr char XRayInstrumentOption[] = "-fxray-instrument";
 constexpr char XRayInstructionThresholdOption[] =
     "-fxray-instruction-threshold=";
+constexpr char XRayInstrumentationBundleOption[] =
+    "-fxray-instrumentation-bundle=";
 } // namespace
 
 XRayArgs::XRayArgs(const ToolChain &TC, const ArgList &Args) {
   const Driver &D = TC.getDriver();
   const llvm::Triple &Triple = TC.getTriple();
   if (Args.hasFlag(options::OPT_fxray_instrument,
                    options::OPT_fnoxray_instrument, false)) {
     if (Triple.getOS() == llvm::Triple::Linux) {
       switch (Triple.getArch()) {
       case llvm::Triple::x86_64:
       case llvm::Triple::arm:
       case llvm::Triple::aarch64:
       case llvm::Triple::ppc64le:
       case llvm::Triple::mips:
       case llvm::Triple::mipsel:
       case llvm::Triple::mips64:
       case llvm::Triple::mips64el:
         break;
       default:
         D.Diag(diag::err_drv_clang_unsupported)
             << (std::string(XRayInstrumentOption) + " on " + Triple.str());
       }
     } else if (Triple.getOS() == llvm::Triple::FreeBSD) {
-        if (Triple.getArch() != llvm::Triple::x86_64) {
-          D.Diag(diag::err_drv_clang_unsupported)
-              << (std::string(XRayInstrumentOption) + " on " + Triple.str());
-        }
     } else {
       D.Diag(diag::err_drv_clang_unsupported)
           << (std::string(XRayInstrumentOption) + " on non-supported target OS");
     }
     XRayInstrument = true;
     if (const Arg *A =
             Args.getLastArg(options::OPT_fxray_instruction_threshold_,
                             options::OPT_fxray_instruction_threshold_EQ)) {
       StringRef S = A->getValue();
       if (S.getAsInteger(0, InstructionThreshold) || InstructionThreshold < 0)
         D.Diag(clang::diag::err_drv_invalid_value) << A->getAsString(Args) << S;
     }
 
     // By default, the back-end will not emit the lowering for XRay customevent
     // calls if the function is not instrumented. In the future we will change
     // this default to be the reverse, but in the meantime we're going to
     // introduce the new functionality behind a flag.
     if (Args.hasFlag(options::OPT_fxray_always_emit_customevents,
                      options::OPT_fnoxray_always_emit_customevents, false))
       XRayAlwaysEmitCustomEvents = true;
 
+    // We check the bundle of instrumentation that we let users choose. This
+    // coarse grained control is used to determine which instrumentation points
+    // to actually emit.
+    if (const Arg *A =
+            Args.getLastArg(options::OPT_fxray_instrumentation_bundle)) {
+      StringRef Bundle = A->getValue();
+      XRayBundle = llvm::StringSwitch<StringRef>(Bundle)
+                       .Case("all", "all")
+                       .Case("none", "none")
+                       .Case("function-extents", "function-extents")
+                       .Case("custom-only", "custom-only")
+                       .Default("error");
+      if (XRayBundle == "error")
+        D.Diag(clang::diag::err_drv_invalid_value)
+            << A->getAsString(Args) << Bundle;
+    }
+
     // Validate the always/never attribute files. We also make sure that they
     // are treated as actual dependencies.
     for (const auto &Filename :
          Args.getAllArgValues(options::OPT_fxray_always_instrument)) {
       if (llvm::sys::fs::exists(Filename)) {
         AlwaysInstrumentFiles.push_back(Filename);
         ExtraDeps.push_back(Filename);
       } else
         D.Diag(clang::diag::err_drv_no_such_file) << Filename;
     }
 
     for (const auto &Filename :
          Args.getAllArgValues(options::OPT_fxray_never_instrument)) {
       if (llvm::sys::fs::exists(Filename)) {
         NeverInstrumentFiles.push_back(Filename);
         ExtraDeps.push_back(Filename);
       } else
void XRayArgs::addArgs(const ToolChain &TC, const ArgList &Args,
 
   CmdArgs.push_back(XRayInstrumentOption);
 
   if (XRayAlwaysEmitCustomEvents)
     CmdArgs.push_back("-fxray-always-emit-customevents");
 
   CmdArgs.push_back(Args.MakeArgString(Twine(XRayInstructionThresholdOption) +
                                        Twine(InstructionThreshold)));
+  CmdArgs.push_back(Args.MakeArgString(Twine(XRayInstrumentationBundleOption) +
+                                       Twine(XRayBundle)));
 
   for (const auto &Always : AlwaysInstrumentFiles) {
     SmallString<64> AlwaysInstrumentOpt("-fxray-always-instrument=");
     AlwaysInstrumentOpt += Always;
     CmdArgs.push_back(Args.MakeArgString(AlwaysInstrumentOpt));
   }
 
   for (const auto &Never : NeverInstrumentFiles) {

clang/lib/Frontend/CompilerInvocation.cpp

for (const auto &Sanitizer : Sanitizers) {
     SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
     if (K == 0)
       Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
     else
       S.set(K, true);
   }
 }
 
+static CodeGenOptions::XRayInstrumentationPointBundle
+parseXRayInstrumentationBundle(Arg *A, ArgList &Args, DiagnosticsEngine &D) {
+  StringRef V = A->getValue();
+  auto Bundle =  llvm::StringSwitch<CodeGenOptions::XRayInstrumentationPointBundle>(V)
+      .Case("all", CodeGenOptions::XRayInstrumentationPointBundle::XRay_All)
+      .Case("none", CodeGenOptions::XRayInstrumentationPointBundle::XRay_None)
+      .Case("function-extents",
+            CodeGenOptions::XRayInstrumentationPointBundle::XRay_Function)
+      .Case("custom-only",
+            CodeGenOptions::XRayInstrumentationPointBundle::XRay_CustomOnly)
+      .Default(CodeGenOptions::XRayInstrumentationPointBundle::XRay_All);
+  if (Bundle == CodeGenOptions::XRayInstrumentationPointBundle::XRay_All &&
+      !V.empty() && V != "all")
+    D.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << V;
+  return Bundle;
+}
+
 // Set the profile kind for fprofile-instrument.
 static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args,
                                DiagnosticsEngine &Diags) {
   Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ);
   if (A == nullptr)
     return;
   StringRef S = A->getValue();
   unsigned I = llvm::StringSwitch<unsigned>(S)
static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   }
 
   Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
   Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
   Opts.InstrumentFunctionsAfterInlining =
       Args.hasArg(OPT_finstrument_functions_after_inlining);
   Opts.InstrumentFunctionEntryBare =
       Args.hasArg(OPT_finstrument_function_entry_bare);
-  Opts.XRayInstrumentFunctions = Args.hasArg(OPT_fxray_instrument);
+
+  Opts.XRayInstrumentFunctions =
+      Args.hasArg(OPT_fxray_instrument);
   Opts.XRayAlwaysEmitCustomEvents =
       Args.hasArg(OPT_fxray_always_emit_customevents);
   Opts.XRayInstructionThreshold =
       getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
+
+  if (auto A = Args.getLastArg(OPT_fxray_instrumentation_bundle))
+    Opts.setXRayInstrumentationBundle(
+        parseXRayInstrumentationBundle(A, Args, 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_fcf_protection_EQ)) {
     StringRef Name = A->getValue();
     if (Name == "full") {
       Opts.CFProtectionReturn = 1;

clang/test/CodeGen/xray-instrumentation-bundles.cpp

+// RUN: %clang_cc1 -fxray-instrument -fxray-instrumentation-bundle=none -x c++ \
+// RUN:     -std=c++11 -triple x86_64-unknown-unknown -emit-llvm -o - %s \
+// RUN:     | FileCheck --check-prefixes CHECK,NOFUNCTION,NOCUSTOM %s
+// RUN: %clang_cc1 -fxray-instrument \
+// RUN:     -fxray-instrumentation-bundle=function-extents -x c++ \
+// RUN:     -std=c++11 -triple x86_64-unknown-unknown -emit-llvm -o - %s \
+// RUN:     | FileCheck --check-prefixes CHECK,FUNCTION,NOCUSTOM %s
+// RUN: %clang_cc1 -fxray-instrument \
+// RUN:     -fxray-instrumentation-bundle=custom-only -x c++ \
+// RUN:     -std=c++11 -triple x86_64-unknown-unknown -emit-llvm -o - %s \
+// RUN:     | FileCheck --check-prefixes CHECK,NOFUNCTION,CUSTOM %s
+
+// CHECK: define void @_Z16alwaysInstrumentv() #[[ALWAYSATTR:[0-9]+]] {
+[[clang::xray_always_instrument]] void alwaysInstrument() {
+  static constexpr char kPhase[] = "always";
+  __xray_customevent(kPhase, 6);
+  // CUSTOM: call void @llvm.xray.customevent(i8*{{.*}}, i32 6)
+  // NOCUSTOM-NOT: call void @llvm.xray.customevent(i8*{{.*}}, i32 6)
+}
+
+// FUNCTION: attributes #[[ALWAYSATTR]] = {{.*}} "function-instrument"="xray-always" {{.*}}
+// NOFUNCTION-NOT: attributes #[[ALWAYSATTR]] = {{.*}} "function-instrument"="xray-always" {{.*}}