add a means of registering emitters per target

Author: farzonl

clang/lib/CodeGen/CGBuiltin.cpp

@@ -18215,9 +18215,11 @@ Value *CodeGenFunction::EmitHLSLMadIntrinsic(const CallExpr *E) {
     Value *Mul = Builder.CreateNUWMul(M, A);
     return Builder.CreateNUWAdd(Mul, B);
   };
-
-  return CGM.getHLSLRuntime().emitHLSLIntrinsic(
-      EmitHLSLIMadDirectX, EmitHLSLIMadGeneric, EmitHLSLIMadGeneric);
+  CGM.getHLSLRuntime().registerHLSLTargetIntrinsic(
+      Builtin::BI__builtin_hlsl_mad, llvm::Triple::dxil, EmitHLSLIMadDirectX);
+  CGM.getHLSLRuntime().registerHLSLGenericIntrinsic(
+      Builtin::BI__builtin_hlsl_mad, EmitHLSLIMadGeneric);
+  return CGM.getHLSLRuntime().emitHLSLIntrinsic(Builtin::BI__builtin_hlsl_mad);
 }
 
 Value *CodeGenFunction::EmitHLSLBuiltinExpr(unsigned BuiltinID,

clang/lib/CodeGen/CGHLSLRuntime.cpp

@@ -119,19 +119,31 @@ llvm::Triple::ArchType CGHLSLRuntime::getArch() {
   return CGM.getTarget().getTriple().getArch();
 }
 
-Value *
-CGHLSLRuntime::emitHLSLIntrinsic(llvm::function_ref<Value *()> DxilEmitter,
-                                 llvm::function_ref<Value *()> SPIRVEmitter,
-                                 llvm::function_ref<Value *()> GenericEmitter) {
+void CGHLSLRuntime::registerHLSLTargetIntrinsic(
+    Builtin::ID Id, llvm::Triple::ArchType Arch,
+    llvm::function_ref<llvm::Value *()> IntrinsicImpl) {
+  if (!IntrinsicCodeGen.count(Id))
+    IntrinsicCodeGen[Id] = CGHLSLIntrinsic();
+  IntrinsicCodeGen[Id].targetImplementations[Arch] = IntrinsicImpl;
+}
+void CGHLSLRuntime::registerHLSLGenericIntrinsic(
+    Builtin::ID Id, llvm::function_ref<llvm::Value *()> IntrinsicImpl) {
+  if (!IntrinsicCodeGen.count(Id))
+    IntrinsicCodeGen[Id] = CGHLSLIntrinsic();
+  IntrinsicCodeGen[Id].genericImplementation = IntrinsicImpl;
+}
+
+llvm::Value *CGHLSLRuntime::emitHLSLIntrinsic(Builtin::ID id) {
+  auto it = IntrinsicCodeGen.find(id);
+  assert(it != IntrinsicCodeGen.end() &&
+         " HLSL intrinsics need to be reigstered before use.");
   llvm::Triple::ArchType Arch = getArch();
-  switch (Arch) {
-  case llvm::Triple::dxil:
-    return DxilEmitter();
-  case llvm::Triple::spirv:
-    return SPIRVEmitter();
-  default:
-    return GenericEmitter();
+  auto targets = it->second.targetImplementations;
+  auto targetIt = targets.find(Arch);
+  if (targetIt == targets.end()) {
+    return it->second.genericImplementation();
   }
+  return targetIt->second();
 }
 
 void CGHLSLRuntime::addConstant(VarDecl *D, Buffer &CB) {

clang/lib/CodeGen/CGHLSLRuntime.h

@@ -51,6 +51,41 @@ class GlobalVariable;
 class Function;
 class StructType;
 class Value;
+
+template <> struct DenseMapInfo<clang::Builtin::ID> {
+  static clang::Builtin::ID getEmptyKey() { return clang::Builtin::NotBuiltin; }
+
+  static clang::Builtin::ID getTombstoneKey() {
+    return clang::Builtin::FirstTSBuiltin;
+  }
+
+  static unsigned getHashValue(clang::Builtin::ID Val) {
+    return static_cast<unsigned>(Val);
+  }
+
+  static bool isEqual(clang::Builtin::ID LHS, clang::Builtin::ID RHS) {
+    return LHS == RHS;
+  }
+};
+
+template <> struct DenseMapInfo<llvm::Triple::ArchType> {
+  static llvm::Triple::ArchType getEmptyKey() {
+    return llvm::Triple::ArchType::UnknownArch;
+  }
+
+  static llvm::Triple::ArchType getTombstoneKey() {
+    return llvm::Triple::ArchType::LastArchType;
+  }
+
+  static unsigned getHashValue(llvm::Triple::ArchType Val) {
+    return static_cast<unsigned>(Val);
+  }
+
+  static bool isEqual(llvm::Triple::ArchType LHS, llvm::Triple::ArchType RHS) {
+    return LHS == RHS;
+  }
+};
+
 } // namespace llvm
 
 namespace clang {
@@ -67,6 +102,15 @@ namespace CodeGen {
 
 class CodeGenModule;
 
+struct CGHLSLIntrinsic {
+  llvm::DenseMap<llvm::Triple::ArchType, llvm::function_ref<llvm::Value *()>>
+      targetImplementations;
+  llvm::function_ref<llvm::Value *()> genericImplementation =
+      []() -> llvm::Value * {
+    llvm_unreachable("Intrinsic not supported by target architecture.");
+  };
+};
+
 class CGHLSLRuntime {
 public:
   //===----------------------------------------------------------------------===//
@@ -80,13 +124,11 @@ class CGHLSLRuntime {
   //===----------------------------------------------------------------------===//
   // End of reserved area for HLSL intrinsic getters.
   //===----------------------------------------------------------------------===//
-  llvm::Value *emitHLSLIntrinsic(
-      llvm::function_ref<llvm::Value *()> DxilEmitter,
-      llvm::function_ref<llvm::Value *()> SPIRVEmitter,
-      llvm::function_ref<llvm::Value *()> GenericEmitter =
-          []() -> llvm::Value * {
-        llvm_unreachable("Intrinsic not supported by target architecture.");
-      });
+  void registerHLSLTargetIntrinsic(Builtin::ID, llvm::Triple::ArchType,
+                                   llvm::function_ref<llvm::Value *()>);
+  void registerHLSLGenericIntrinsic(Builtin::ID,
+                                    llvm::function_ref<llvm::Value *()>);
+  llvm::Value *emitHLSLIntrinsic(Builtin::ID);
   struct BufferResBinding {
     // The ID like 2 in register(b2, space1).
     std::optional<unsigned> Reg;
@@ -137,6 +179,7 @@ class CGHLSLRuntime {
   void addBufferDecls(const DeclContext *DC, Buffer &CB);
   llvm::Triple::ArchType getArch();
   llvm::SmallVector<Buffer> Buffers;
+  llvm::DenseMap<clang::Builtin::ID, CGHLSLIntrinsic> IntrinsicCodeGen;
 };
 
 } // namespace CodeGen