uda: add realTimeUnsafe LDC-specific attribute ...

... this attribute can be used to mark a function as "blocking" (same
mechanism as Clang's `[[clang::blocking]]` C/C++ attribute.

Author: liushuyu

dmd/id.d

@@ -584,6 +584,7 @@ immutable Msgtable[] msgtable =
     { "udaNoSanitize", "noSanitize" },
     { "udaNoSplitStack", "_noSplitStack" },
     { "udaSwiftStub", "swift"},
+    { "udaRealTimeUnsafe", "_realTimeUnsafe"},
 
     // IN_LLVM: DCompute specific types and functionss
     { "dcompute" },

dmd/id.h

@@ -98,6 +98,7 @@ struct Id
     static Identifier *udaHidden;
     static Identifier *udaNoSanitize;
     static Identifier *udaNoSplitStack;
+    static Identifier *udaRealTimeUnsafe;
     static Identifier *io;
 #endif
 };

gen/functions.cpp

@@ -1178,7 +1178,10 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
 
 #if LDC_LLVM_VER >= 2000
     if (opts::isSanitizerEnabled(opts::RealTimeSanitizer & noSanitizeMask)) {
-      func->addFnAttr(LLAttribute::SanitizeRealtime);
+      // mimick the `[[clang::blocking]]` attribute behavior
+      func->addFnAttr(hasRealTimeUnsafeUDA(fd)
+                          ? LLAttribute::SanitizeRealtimeBlocking
+                          : LLAttribute::SanitizeRealtime);
     }
 #endif
   }

gen/uda.cpp

@@ -677,6 +677,12 @@ bool hasNoSplitStackUDA(FuncDeclaration *fd) {
   return sle != nullptr;
 }
 
+/// Check whether `fd` has the `@ldc.attributes.realTimeUnsafe` UDA applied.
+bool hasRealTimeUnsafeUDA(FuncDeclaration *fd) {
+  auto sle = getMagicAttribute(fd, Id::udaRealTimeUnsafe, Id::attributes);
+  return sle != nullptr;
+}
+
 /// Creates a mask (for &) of @ldc.attributes.noSanitize UDA applied to the
 /// function.
 /// If a bit is set in the mask, then the sanitizer is enabled.

gen/uda.h

@@ -39,5 +39,6 @@ enum class DComputeCompileFor : int
 };
 extern "C" DComputeCompileFor hasComputeAttr(Dsymbol *sym);
 bool hasNoSplitStackUDA(FuncDeclaration *fd);
+bool hasRealTimeUnsafeUDA(FuncDeclaration *fd);
 
 unsigned getMaskFromNoSanitizeUDA(FuncDeclaration &fd);

runtime/druntime/src/ldc/attributes.d

@@ -308,6 +308,22 @@ private struct _noSplitStack
 {
 }
 
+/**
+ * Marks this function as real-time unsafe.
+ * This attribute is akin to Clang's `[[clang::blocking]]` attribute
+ * and is only effective when realtime sanitizer is enabled
+ * (e.g. by specifying `-fsanitize=realtime` on the commandline).
+ *
+ * If you have a function that is real-time unsafe, rather than using
+ * `@noSanitize("realtime")` to disable the check, please use this attribute
+ * to mark the function as real-time unsafe. The sanitizer will also skip
+ * checking this function for real-time violations.
+ */
+immutable realTimeUnsafe = _realTimeUnsafe();
+private struct _realTimeUnsafe
+{
+}
+
 /**
  * Sets the optimization strategy for a function.
  * Valid strategies are "none", "optsize", "minsize". The strategies are mutually exclusive.