[XRay] Add __xray_customeevent(...) as a clang-supported builtin

[dberris]

Summary

We define the __xray_customeevent builtin that gets translated to
IR calls to the correct intrinsic. The default implementation of this is
a no-op function. The codegen side of this follows the following logic:

• When -fxray-instrument is not provided in the driver, we elide all calls to __xray_customevent.
• When -fxray-instrument is enabled and a function is marked as "never instrumented", we elide all calls to __xray_customevent in that function; if either marked as "always instrumented" or subject to threshold-based instrumentation, we emit a call to the llvm.xray.customevent intrinsic from LLVM for each __xray_customevent occurrence in the function.

This change depends on D27503 (to land in LLVM first).

[dberris]

@rnk -- if you have time, a review for this would be appreciated too.

[rnk]

lib/CodeGen/CGBuiltin.cpp

2748 ↗

(On Diff #88641)

Don't need this->

2753–2754 ↗

(On Diff #88641)

I don't think we need this FIXME. We don't generally assert things that are supposed to be guaranteed by semantic checking unless Sema proves to be unreliable.

2755 ↗

(On Diff #88641)

We don't need a vector, CreateCall can take a std::initializer_list, so you can write Builder.CreateCall(F, {Arg0Val, Arg1Val}).

2763 ↗

(On Diff #88641)

OK, that is annoying, but it looks like it's what the other builtins do already. *shrug*

2773–2774 ↗

(On Diff #88641)

This is probably simpler as return RValue::get(Builder.CreateCall(F, {Arg0Val, Arg1Val});

lib/Headers/xrayintrin.h

28 ↗

(On Diff #88641)

I don't think you need this header. Also, the extern "C" would have to be guarded on __cplusplus.

[dberris]

Address comments.

lib/Headers/xrayintrin.h

28 ↗

(On Diff #88641)

Reverted the file.

[rnk]

lgtm

lib/CodeGen/CGBuiltin.cpp

2748 ↗

(On Diff #88641)

Do you think this-> is necessary?

[dberris]

Thanks @rnk!

lib/CodeGen/CGBuiltin.cpp

2748 ↗

(On Diff #88641)

Nope, just force of habit (and an aid to autocomplete) :D

cfe/trunk/include/clang/Basic/Builtins.def

 LANGBUILTIN(to_global, "v*v*", "tn", OCLC20_LANG)
 LANGBUILTIN(to_local, "v*v*", "tn", OCLC20_LANG)
 LANGBUILTIN(to_private, "v*v*", "tn", OCLC20_LANG)
 
 // Builtins for os_log/os_trace
 BUILTIN(__builtin_os_log_format_buffer_size, "zcC*.", "p:0:nut")
 BUILTIN(__builtin_os_log_format, "v*v*cC*.", "p:0:nt")
 
+// Builtins for XRay
+BUILTIN(__xray_customevent, "vcC*z", "")
+
 #undef BUILTIN
 #undef LIBBUILTIN
 #undef LANGBUILTIN

cfe/trunk/lib/CodeGen/CGBuiltin.cpp

   }
 
   case Builtin::BI__builtin_os_log_format_buffer_size: {
     analyze_os_log::OSLogBufferLayout Layout;
     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();
+    if (const auto *XRayAttr = CurFuncDecl->getAttr<XRayInstrumentAttr>()) {
+      if (XRayAttr->neverXRayInstrument())
+        return RValue::getIgnored();
+    }
+    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);
+    }
+    auto Arg1 = EmitScalarExpr(E->getArg(1));
+    auto PTy1 = FTy->getParamType(1);
+    if (PTy1 != Arg1->getType())
+      Arg1 = Builder.CreateTruncOrBitCast(Arg1, PTy1);
+    return RValue::get(Builder.CreateCall(F, {Arg0Val, Arg1}));
+  }
   }
 
   // If this is an alias for a lib function (e.g. __builtin_sin), emit
   // the call using the normal call path, but using the unmangled
   // version of the function name.
   if (getContext().BuiltinInfo.isLibFunction(BuiltinID))
     return emitLibraryCall(*this, FD, E,
                            CGM.getBuiltinLibFunction(FD, BuiltinID));

cfe/trunk/test/CodeGen/xray-customevent.cpp

+// RUN: %clang_cc1 -fxray-instrument -x c++ -std=c++11 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s
+
+// CHECK-LABEL: @_Z16alwaysInstrumentv
+[[clang::xray_always_instrument]] void alwaysInstrument() {
+  static constexpr char kPhase[] = "instrument";
+  __xray_customevent(kPhase, 10);
+  // CHECK: call void @llvm.xray.customevent(i8*{{.*}}, i32 10)
+}
+
+// CHECK-LABEL: @_Z15neverInstrumentv
+[[clang::xray_never_instrument]] void neverInstrument() {
+  static constexpr char kPhase[] = "never";
+  __xray_customevent(kPhase, 5);
+  // CHECK-NOT: call void @llvm.xray.customevent(i8*{{.*}}, i32 5)
+}
+
+// CHECK-LABEL: @_Z21conditionalInstrumenti
+[[clang::xray_always_instrument]] void conditionalInstrument(int v) {
+  static constexpr char kTrue[] = "true";
+  static constexpr char kUntrue[] = "untrue";
+  if (v % 2)
+    __xray_customevent(kTrue, 4);
+  else
+    __xray_customevent(kUntrue, 6);
+
+  // CHECK: call void @llvm.xray.customevent(i8*{{.*}}, i32 4)
+  // CHECK: call void @llvm.xray.customevent(i8*{{.*}}, i32 6)
+}