[NFC] [DirectX backend] move ResourceClass into llvm.

[python3kgae]

Summary

Move ResourceClass into llvm/Frontend/HLSL/HLSLResource.h so it could be shared between clang and DirectX backend.

[python3kgae]

Rebase

[beanz]

clang/lib/Sema/HLSLExternalSemaSource.cpp

20

You need to add FrontendHLSL to the Sema/CMakeLists.txt file too.

[python3kgae]

clang/lib/Sema/HLSLExternalSemaSource.cpp

20

Good catch.
Not sure why both local build and the pre-commit check cannot hit it. :(

[python3kgae]

clang/lib/Sema/HLSLExternalSemaSource.cpp

20

I think the reason it works is that it only used the enum decl in the header, not anything which needs to link.
Do we need to add FrontendHLSL to CMakeLists in this case?

[beanz]

clang/lib/Sema/HLSLExternalSemaSource.cpp

20

The first header include added to a component should add the linkage dependency (even if it isn't strictly needed).

It is too easy to add a linkage dependency later without realizing it isn't already specified. Because of how static archive linking works you don't necessarily notice the missing dependency because many of our tools link both Sema and CodeGen where there is already a dependency.

[python3kgae]

Add FrontendHLSL to Sema link

clang/lib/Sema/HLSLExternalSemaSource.cpp

20

Got it.
Updated.

clang/include/clang/Basic/HLSLRuntime.h

 #define CLANG_BASIC_HLSLRUNTIME_H
 
 #include "clang/Basic/LangOptions.h"
 #include <cstdint>
 
 namespace clang {
 namespace hlsl {
 
-enum class ResourceClass : uint8_t {
-  SRV = 0,
-  UAV,
-  CBuffer,
-  Sampler,
-  NumClasses
-};
-
 constexpr ShaderStage
 getStageFromEnvironment(const llvm::Triple::EnvironmentType &E) {
   uint32_t Pipeline =
       static_cast<uint32_t>(E) - static_cast<uint32_t>(llvm::Triple::Pixel);
 
   if (Pipeline > (uint32_t)ShaderStage::Invalid)
     return ShaderStage::Invalid;
   return static_cast<ShaderStage>(Pipeline);

clang/lib/CodeGen/CGHLSLRuntime.h

struct Buffer {
     // Global variable and offset for each constant.
     std::vector<std::pair<llvm::GlobalVariable *, unsigned>> Constants;
     llvm::StructType *LayoutStruct = nullptr;
   };
 
 protected:
   CodeGenModule &CGM;
   uint32_t ResourceCounters[static_cast<uint32_t>(
-      hlsl::ResourceClass::NumClasses)] = {0};
+      llvm::hlsl::ResourceClass::NumClasses)] = {0};
 
   llvm::Value *emitInputSemantic(llvm::IRBuilder<> &B, const ParmVarDecl &D,
                                  llvm::Type *Ty);
 
 public:
   CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
   virtual ~CGHLSLRuntime() {}
 
   void annotateHLSLResource(const VarDecl *D, llvm::GlobalVariable *GV);
   void generateGlobalCtorDtorCalls();
 
   void addBuffer(const HLSLBufferDecl *D);
   void finishCodeGen();
 
   void setHLSLEntryAttributes(const FunctionDecl *FD, llvm::Function *Fn);
 
   void emitEntryFunction(const FunctionDecl *FD, llvm::Function *Fn);
   void setHLSLFunctionAttributes(llvm::Function *, const FunctionDecl *);
 
 private:
   void addBufferResourceAnnotation(llvm::GlobalVariable *GV,
                                    llvm::StringRef TyName,
-                                   hlsl::ResourceClass RC,
+                                   llvm::hlsl::ResourceClass RC,
                                    llvm::hlsl::ResourceKind RK,
                                    BufferResBinding &Binding);
   void addConstant(VarDecl *D, Buffer &CB);
   void addBufferDecls(const DeclContext *DC, Buffer &CB);
   llvm::SmallVector<Buffer> Buffers;
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif

clang/lib/CodeGen/CGHLSLRuntime.cpp

 #include "clang/Basic/TargetOptions.h"
 #include "llvm/IR/IntrinsicsDirectX.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace clang;
 using namespace CodeGen;
-using namespace hlsl;
+using namespace clang::hlsl;
 using namespace llvm;
 
 namespace {
 
 void addDxilValVersion(StringRef ValVersionStr, llvm::Module &M) {
   // The validation of ValVersionStr is done at HLSLToolChain::TranslateArgs.
   // Assume ValVersionStr is legal here.
   VersionTuple Version;
if (CGM.getCodeGenOpts().OptimizationLevel == 0)
     addDisableOptimizations(M);
 
   const DataLayout &DL = M.getDataLayout();
 
   for (auto &Buf : Buffers) {
     layoutBuffer(Buf, DL);
     GlobalVariable *GV = replaceBuffer(Buf);
     M.getGlobalList().push_back(GV);
-    hlsl::ResourceClass RC =
-        Buf.IsCBuffer ? hlsl::ResourceClass::CBuffer : hlsl::ResourceClass::SRV;
+    llvm::hlsl::ResourceClass RC = Buf.IsCBuffer
+                                       ? llvm::hlsl::ResourceClass::CBuffer
+                                       : llvm::hlsl::ResourceClass::SRV;
     llvm::hlsl::ResourceKind RK = Buf.IsCBuffer
                                       ? llvm::hlsl::ResourceKind::CBuffer
                                       : llvm::hlsl::ResourceKind::TBuffer;
     std::string TyName =
         Buf.Name.str() + (Buf.IsCBuffer ? ".cb." : ".tb.") + "ty";
     addBufferResourceAnnotation(GV, TyName, RC, RK, Buf.Binding);
   }
 }
 
 CGHLSLRuntime::Buffer::Buffer(const HLSLBufferDecl *D)
     : Name(D->getName()), IsCBuffer(D->isCBuffer()),
       Binding(D->getAttr<HLSLResourceBindingAttr>()) {}
 
 void CGHLSLRuntime::addBufferResourceAnnotation(llvm::GlobalVariable *GV,
                                                 llvm::StringRef TyName,
-                                                hlsl::ResourceClass RC,
+                                                llvm::hlsl::ResourceClass RC,
                                                 llvm::hlsl::ResourceKind RK,
                                                 BufferResBinding &Binding) {
   uint32_t Counter = ResourceCounters[static_cast<uint32_t>(RC)]++;
   llvm::Module &M = CGM.getModule();
 
   NamedMDNode *ResourceMD = nullptr;
   switch (RC) {
-  case hlsl::ResourceClass::UAV:
+  case llvm::hlsl::ResourceClass::UAV:
     ResourceMD = M.getOrInsertNamedMetadata("hlsl.uavs");
     break;
-  case hlsl::ResourceClass::SRV:
+  case llvm::hlsl::ResourceClass::SRV:
     ResourceMD = M.getOrInsertNamedMetadata("hlsl.srvs");
     break;
-  case hlsl::ResourceClass::CBuffer:
+  case llvm::hlsl::ResourceClass::CBuffer:
     ResourceMD = M.getOrInsertNamedMetadata("hlsl.cbufs");
     break;
   default:
     assert(false && "Unsupported buffer type!");
     return;
   }
 
   assert(ResourceMD != nullptr &&
if (!Attr)
     return;
 
   HLSLResourceAttr::ResourceClass RC = Attr->getResourceType();
   llvm::hlsl::ResourceKind RK =
       castResourceShapeToResourceKind(Attr->getResourceShape());
 
   QualType QT(Ty, 0);
   BufferResBinding Binding(D->getAttr<HLSLResourceBindingAttr>());
-  addBufferResourceAnnotation(
-      GV, QT.getAsString(), static_cast<hlsl::ResourceClass>(RC), RK, Binding);
+  addBufferResourceAnnotation(GV, QT.getAsString(),
+                              static_cast<llvm::hlsl::ResourceClass>(RC), RK,
+                              Binding);
 }
 
 CGHLSLRuntime::BufferResBinding::BufferResBinding(
     HLSLResourceBindingAttr *Binding) {
   if (Binding) {
     llvm::APInt RegInt(64, 0);
     Binding->getSlot().substr(1).getAsInteger(10, RegInt);
     Reg = RegInt.getLimitedValue();

clang/lib/Sema/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
+  FrontendHLSL
   FrontendOpenMP
   MC
   Support
   )
 
 clang_tablegen(OpenCLBuiltins.inc -gen-clang-opencl-builtins
   SOURCE OpenCLBuiltins.td
   TARGET ClangOpenCLBuiltinsImpl

clang/lib/Sema/HLSLExternalSemaSource.cpp

 #include "clang/Sema/HLSLExternalSemaSource.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/Basic/AttrKinds.h"
 #include "clang/Basic/HLSLRuntime.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Sema.h"
+#include "llvm/Frontend/HLSL/HLSLResource.h"
 
 #include <functional>
 
 using namespace clang;
-using namespace hlsl;
+using namespace llvm::hlsl;
 
 namespace {
 
 struct TemplateParameterListBuilder;
 
 struct BuiltinTypeDeclBuilder {
   CXXRecordDecl *Record = nullptr;
   ClassTemplateDecl *Template = nullptr;

llvm/include/llvm/Frontend/HLSL/HLSLResource.h

 #include "llvm/IR/Metadata.h"
 
 namespace llvm {
 class Module;
 class GlobalVariable;
 
 namespace hlsl {
 
+enum class ResourceClass : uint8_t {
+  SRV = 0,
+  UAV,
+  CBuffer,
+  Sampler,
+  Invalid,
+  NumClasses = Invalid,
+};
+
 // The value ordering of this enumeration is part of the DXIL ABI. Elements
 // can only be added to the end, and not removed.
 enum class ResourceKind : uint32_t {
   Invalid = 0,
   Texture1D,
   Texture2D,
   Texture2DMS,
   Texture3D,