add a templated macro for when we have builtins

and make GENERATE_HLSL_INTRINSIC_FUNCTION take a function name

Author: farzonl

clang/lib/CodeGen/CGBuiltin.cpp

@@ -18177,8 +18177,9 @@ Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID,
     Value *Op0 = EmitScalarExpr(E->getArg(0));
     return Builder.CreateIntrinsic(
         /*ReturnType=*/llvm::Type::getInt1Ty(getLLVMContext()),
-        CGM.getHLSLRuntime().get_hlsl_all_intrinsic(), ArrayRef<Value *>{Op0},
-        nullptr, "hlsl.all");
+        CGM.getHLSLRuntime()
+            .getIntrinsic<Builtin::BI__builtin_hlsl_elementwise_all>(),
+        ArrayRef<Value *>{Op0}, nullptr, "hlsl.all");
   }
   case Builtin::BI__builtin_hlsl_elementwise_any: {
     Value *Op0 = EmitScalarExpr(E->getArg(0));

clang/lib/CodeGen/CGHLSLRuntime.cpp

@@ -346,7 +346,7 @@ llvm::Value *CGHLSLRuntime::emitInputSemantic(IRBuilder<> &B,
   }
   if (D.hasAttr<HLSLSV_DispatchThreadIDAttr>()) {
     llvm::Function *ThreadIDIntrinsic =
-        CGM.getIntrinsic(get_hlsl_thread_id_intrinsic());
+        CGM.getIntrinsic(getThreadIdIntrinsic());
     return buildVectorInput(B, ThreadIDIntrinsic, Ty);
   }
   assert(false && "Unhandled parameter attribute");

clang/lib/CodeGen/CGHLSLRuntime.h

@@ -20,6 +20,7 @@
 #include "llvm/IR/IntrinsicsDirectX.h"
 #include "llvm/IR/IntrinsicsSPIRV.h"
 
+#include "clang/Basic/Builtins.h"
 #include "clang/Basic/HLSLRuntime.h"
 
 #include "llvm/ADT/SmallVector.h"
@@ -29,19 +30,29 @@
 #include <optional>
 #include <vector>
 
-// Define the function generator macro
-#define GENERATE_HLSL_INTRINSIC_FUNCTION(name)                                 \
-  llvm::Intrinsic::ID get_hlsl_##name##_intrinsic() {                          \
-    llvm::Triple::ArchType Arch = getArch();                                   \
-    switch (Arch) {                                                            \
-    case llvm::Triple::dxil:                                                   \
-      return llvm::Intrinsic::dx_##name;                                       \
-    case llvm::Triple::spirv:                                                  \
-      return llvm::Intrinsic::spv_##name;                                      \
-    default:                                                                   \
-      llvm_unreachable("Intrinsic " #name                                      \
-                       " not supported by target architecture");               \
-    }                                                                          \
+#define GENERATE_HLSL_INTRINSIC_BASE(IntrinsicPostfix)                         \
+  llvm::Triple::ArchType Arch = getArch();                                     \
+  switch (Arch) {                                                              \
+  case llvm::Triple::dxil:                                                     \
+    return llvm::Intrinsic::dx_##IntrinsicPostfix;                             \
+  case llvm::Triple::spirv:                                                    \
+    return llvm::Intrinsic::spv_##IntrinsicPostfix;                            \
+  default:                                                                     \
+    llvm_unreachable("Intrinsic " #IntrinsicPostfix                            \
+                     " not supported by target architecture");                 \
+  }
+
+// A function generator macro for when there is no builtins or
+// when builtins are mapped to a set of intrinsics for different types.
+#define GENERATE_HLSL_INTRINSIC_FUNCTION(FunctionName, IntrinsicPostfix)       \
+  llvm::Intrinsic::ID get##FunctionName##Intrinsic() {                         \
+    GENERATE_HLSL_INTRINSIC_BASE(IntrinsicPostfix)                             \
+  }
+
+// A template function generator macro for when we have builtins.
+#define GENERATE_HLSL_INTRINSIC_TEMPLATE(BuiltinName, IntrinsicPostfix)        \
+  template <> llvm::Intrinsic::ID getIntrinsic<Builtin::BI__##BuiltinName>() { \
+    GENERATE_HLSL_INTRINSIC_BASE(IntrinsicPostfix)                             \
   }
 
 namespace llvm {
@@ -69,9 +80,9 @@ class CGHLSLRuntime {
   //===----------------------------------------------------------------------===//
   // Start of reserved area for HLSL intrinsic getters.
   //===----------------------------------------------------------------------===//
-
-  GENERATE_HLSL_INTRINSIC_FUNCTION(all)
-  GENERATE_HLSL_INTRINSIC_FUNCTION(thread_id)
+  template <unsigned BI> llvm::Intrinsic::ID getIntrinsic();
+  GENERATE_HLSL_INTRINSIC_TEMPLATE(builtin_hlsl_elementwise_all, all)
+  GENERATE_HLSL_INTRINSIC_FUNCTION(ThreadId, thread_id)
 
   //===----------------------------------------------------------------------===//
   // End of reserved area for HLSL intrinsic getters.