[DirectX backend] [NFC] Change Resources::write to const.

[python3kgae]

Summary

Change Resources::write to const.
Also fix parameter name.

llvm/lib/Target/DirectX/DXILResource.h

protected:
   uint32_t ID;
   GlobalVariable *GV;
   StringRef Name;
   uint32_t Space;
   uint32_t LowerBound;
   uint32_t RangeSize;
   ResourceBase(uint32_t I, FrontendResource R);
 
-  void write(LLVMContext &Ctx, MutableArrayRef<Metadata *> Entries);
+  void write(LLVMContext &Ctx, MutableArrayRef<Metadata *> Entries) const;
 
   void print(raw_ostream &O, StringRef IDPrefix, StringRef BindingPrefix) const;
 
   // 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 Kinds : uint32_t {
     Invalid = 0,
     Texture1D,
enum class Kinds : uint32_t {
     TBuffer,
     RTAccelerationStructure,
     FeedbackTexture2D,
     FeedbackTexture2DArray,
     NumEntries,
   };
 
   static StringRef getKindName(Kinds Kind);
-  static void printKind(Kinds Kind, unsigned alignment, raw_ostream &OS,
+  static void printKind(Kinds Kind, unsigned Alignment, raw_ostream &OS,
                         bool SRV = false, bool HasCounter = false,
                         uint32_t SampleCount = 0);
 
   // 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 ComponentType : uint32_t {
     Invalid = 0,
     I1,
enum class ComponentType : uint32_t {
     UNormF64,
     PackedS8x32,
     PackedU8x32,
     LastEntry
   };
 
   static StringRef getComponentTypeName(ComponentType CompType);
   static void printComponentType(Kinds Kind, ComponentType CompType,
-                                 unsigned alignment, raw_ostream &OS);
+                                 unsigned Alignment, raw_ostream &OS);
 
 public:
   struct ExtendedProperties {
     llvm::Optional<ComponentType> ElementType;
 
     // The value ordering of this enumeration is part of the DXIL ABI. Elements
     // can only be added to the end, and not removed.
     enum Tags : uint32_t {
       TypedBufferElementType = 0,
       StructuredBufferElementStride,
       SamplerFeedbackKind,
       Atomic64Use
     };
 
-    MDNode *write(LLVMContext &Ctx);
+    MDNode *write(LLVMContext &Ctx) const;
   };
 };
 
 class UAVResource : public ResourceBase {
   ResourceBase::Kinds Shape;
   bool GloballyCoherent;
   bool HasCounter;
   bool IsROV;
   ResourceBase::ExtendedProperties ExtProps;
 
   void parseSourceType(StringRef S);
 
 public:
   UAVResource(uint32_t I, FrontendResource R);
 
-  MDNode *write();
+  MDNode *write() const;
   void print(raw_ostream &O) const;
 };
 
 // FIXME: Fully computing the resource structures requires analyzing the IR
 // because some flags are set based on what operations are performed on the
 // resource. This partial patch handles some of the leg work, but not all of it.
 // See issue https://github.com/llvm/llvm-project/issues/57936.
 class Resources {
   llvm::SmallVector<UAVResource> UAVs;
 
   void collectUAVs(Module &M);
 
 public:
   void collect(Module &M);
-
-  void write(Module &M);
+  void write(Module &M) const;
   void print(raw_ostream &O) const;
   LLVM_DUMP_METHOD void dump() const;
 };
 
 } // namespace dxil
 } // namespace llvm
 
 #endif // LLVM_TARGET_DIRECTX_DXILRESOURCE_H

llvm/lib/Target/DirectX/DXILResource.cpp

StringRef ResourceBase::getComponentTypeName(ComponentType CompType) {
   case ComponentType::PackedS8x32:
     return "p32i8";
   case ComponentType::PackedU8x32:
     return "p32u8";
   }
 }
 
 void ResourceBase::printComponentType(Kinds Kind, ComponentType CompType,
-                                      unsigned alignment, raw_ostream &OS) {
+                                      unsigned Alignment, raw_ostream &OS) {
   switch (Kind) {
   default:
     // TODO: add vector size.
-    OS << right_justify(getComponentTypeName(CompType), alignment);
+    OS << right_justify(getComponentTypeName(CompType), Alignment);
     break;
   case Kinds::RawBuffer:
-    OS << right_justify("byte", alignment);
+    OS << right_justify("byte", Alignment);
     break;
   case Kinds::StructuredBuffer:
-    OS << right_justify("struct", alignment);
+    OS << right_justify("struct", Alignment);
     break;
   case Kinds::CBuffer:
   case Kinds::Sampler:
-    OS << right_justify("NA", alignment);
+    OS << right_justify("NA", Alignment);
     break;
   case Kinds::Invalid:
   case Kinds::NumEntries:
     break;
   }
 }
 
 StringRef ResourceBase::getKindName(Kinds Kind) {
case Kinds::RTAccelerationStructure:
     return "ras";
   case Kinds::FeedbackTexture2D:
     return "fbtex2d";
   case Kinds::FeedbackTexture2DArray:
     return "fbtex2darray";
   }
 }
 
-void ResourceBase::printKind(Kinds Kind, unsigned alignment, raw_ostream &OS,
+void ResourceBase::printKind(Kinds Kind, unsigned Alignment, raw_ostream &OS,
                              bool SRV, bool HasCounter, uint32_t SampleCount) {
   switch (Kind) {
   default:
-    OS << right_justify(getKindName(Kind), alignment);
+    OS << right_justify(getKindName(Kind), Alignment);
     break;
 
   case Kinds::RawBuffer:
   case Kinds::StructuredBuffer:
     if (SRV)
-      OS << right_justify("r/o", alignment);
+      OS << right_justify("r/o", Alignment);
     else {
       if (!HasCounter)
-        OS << right_justify("r/w", alignment);
+        OS << right_justify("r/w", Alignment);
       else
-        OS << right_justify("r/w+cnt", alignment);
+        OS << right_justify("r/w+cnt", Alignment);
     }
     break;
   case Kinds::TypedBuffer:
-    OS << right_justify("buf", alignment);
+    OS << right_justify("buf", Alignment);
     break;
   case Kinds::Texture2DMS:
   case Kinds::Texture2DMSArray: {
-    std::string dimName = getKindName(Kind).str();
+    std::string DimName = getKindName(Kind).str();
     if (SampleCount)
-      dimName += std::to_string(SampleCount);
-    OS << right_justify(dimName, alignment);
+      DimName += std::to_string(SampleCount);
+    OS << right_justify(DimName, Alignment);
   } break;
   case Kinds::CBuffer:
   case Kinds::Sampler:
-    OS << right_justify("NA", alignment);
+    OS << right_justify("NA", Alignment);
     break;
   case Kinds::Invalid:
   case Kinds::NumEntries:
     break;
   }
 }
 
 void ResourceBase::print(raw_ostream &OS, StringRef IDPrefix,
ComponentType ElTy = StringSwitch<ResourceBase::ComponentType>(S)
                            .Case("half", ComponentType::F16)
                            .Case("float", ComponentType::F32)
                            .Case("double", ComponentType::F64)
                            .Default(ComponentType::Invalid);
   if (ElTy != ComponentType::Invalid)
     ExtProps.ElementType = ElTy;
 }
 
-MDNode *ResourceBase::ExtendedProperties::write(LLVMContext &Ctx) {
+MDNode *ResourceBase::ExtendedProperties::write(LLVMContext &Ctx) const {
   IRBuilder<> B(Ctx);
   SmallVector<Metadata *> Entries;
   if (ElementType) {
     Entries.emplace_back(
         ConstantAsMetadata::get(B.getInt32(TypedBufferElementType)));
     Entries.emplace_back(ConstantAsMetadata::get(
         B.getInt32(static_cast<uint32_t>(*ElementType))));
   }
   if (Entries.empty())
     return nullptr;
   return MDNode::get(Ctx, Entries);
 }
 
 void ResourceBase::write(LLVMContext &Ctx,
-                         MutableArrayRef<Metadata *> Entries) {
+                         MutableArrayRef<Metadata *> Entries) const {
   IRBuilder<> B(Ctx);
   Entries[0] = ConstantAsMetadata::get(B.getInt32(ID));
   Entries[1] = ConstantAsMetadata::get(GV);
   Entries[2] = MDString::get(Ctx, Name);
   Entries[3] = ConstantAsMetadata::get(B.getInt32(Space));
   Entries[4] = ConstantAsMetadata::get(B.getInt32(LowerBound));
   Entries[5] = ConstantAsMetadata::get(B.getInt32(RangeSize));
 }
 
-MDNode *UAVResource::write() {
+MDNode *UAVResource::write() const {
   auto &Ctx = GV->getContext();
   IRBuilder<> B(Ctx);
   Metadata *Entries[11];
   ResourceBase::write(Ctx, Entries);
   Entries[6] =
       ConstantAsMetadata::get(B.getInt32(static_cast<uint32_t>(Shape)));
   Entries[7] = ConstantAsMetadata::get(B.getInt1(GloballyCoherent));
   Entries[8] = ConstantAsMetadata::get(B.getInt1(HasCounter));
   Entries[9] = ConstantAsMetadata::get(B.getInt1(IsROV));
   Entries[10] = ExtProps.write(Ctx);
   return MDNode::get(Ctx, Entries);
 }
 
-void Resources::write(Module &M) {
+void Resources::write(Module &M) const {
   Metadata *ResourceMDs[4] = {nullptr, nullptr, nullptr, nullptr};
   SmallVector<Metadata *> UAVMDs;
   for (auto &UAV : UAVs)
     UAVMDs.emplace_back(UAV.write());
 
   if (!UAVMDs.empty())
     ResourceMDs[1] = MDNode::get(M.getContext(), UAVMDs);
 

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

 
 bool DXILTranslateMetadata::runOnModule(Module &M) {
 
   dxil::ValidatorVersionMD ValVerMD(M);
   if (ValVerMD.isEmpty())
     ValVerMD.update(VersionTuple(1, 0));
   dxil::createShaderModelMD(M);
 
-  dxil::Resources &Res = getAnalysis<DXILResourceWrapper>().getDXILResource();
+  const dxil::Resources &Res =
+      getAnalysis<DXILResourceWrapper>().getDXILResource();
   Res.write(M);
   return false;
 }
 
 char DXILTranslateMetadata::ID = 0;
 
 ModulePass *llvm::createDXILTranslateMetadataPass() {
   return new DXILTranslateMetadata();
 }
 
 INITIALIZE_PASS_BEGIN(DXILTranslateMetadata, "dxil-metadata-emit",
                       "DXIL Metadata Emit", false, false)
 INITIALIZE_PASS_DEPENDENCY(DXILResourceWrapper)
 INITIALIZE_PASS_END(DXILTranslateMetadata, "dxil-metadata-emit",
                     "DXIL Metadata Emit", false, false)