refactoring to follow llvm standards

Author: joaosaffran

llvm/include/llvm/MC/DXContainerRootSignature.h

@@ -0,0 +1,27 @@
+//===- llvm/MC/DXContainerRootSignature.h - DXContainer RootSignature -*- C++
+//-------*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstdint>
+#include <limits>
+
+namespace llvm {
+
+class raw_ostream;
+
+namespace mcdxbc {
+struct RootSignatureHeader {
+  uint32_t Version;
+  uint32_t Flags;
+
+  void swapBytes();
+  void write(raw_ostream &OS,
+             uint32_t Version = std::numeric_limits<uint32_t>::max());
+};
+} // namespace mcdxbc
+} // namespace llvm

llvm/include/llvm/Object/DXContainer.h

@@ -22,6 +22,8 @@
 #include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/TargetParser/Triple.h"
 #include <array>
+#include <cstdint>
+#include <sys/types.h>
 #include <variant>
 
 namespace llvm {
@@ -116,6 +118,23 @@ template <typename T> struct ViewArray {
 };
 
 namespace DirectX {
+
+class RootSignature {
+private:
+  StringRef Data;
+  uint32_t Version;
+  uint32_t Flags;
+
+public:
+  RootSignature(StringRef Data) : Data(Data) {}
+
+  Error parse();
+
+  uint32_t getVersion() const { return Version; }
+
+  uint32_t getFlags() const { return Flags; }
+};
+
 class PSVRuntimeInfo {
 
   using ResourceArray = ViewArray<dxbc::PSV::v2::ResourceBindInfo>;
@@ -287,7 +306,7 @@ class DXContainer {
   std::optional<uint64_t> ShaderFeatureFlags;
   std::optional<dxbc::ShaderHash> Hash;
   std::optional<DirectX::PSVRuntimeInfo> PSVInfo;
-  std::optional<dxbc::RootSignatureDesc> RootSignature;
+  std::optional<DirectX::RootSignature> RootSignature;
   DirectX::Signature InputSignature;
   DirectX::Signature OutputSignature;
   DirectX::Signature PatchConstantSignature;
@@ -384,7 +403,7 @@ class DXContainer {
 
   std::optional<dxbc::ShaderHash> getShaderHash() const { return Hash; }
 
-  std::optional<dxbc::RootSignatureDesc> getRootSignature() const {
+  std::optional<DirectX::RootSignature> getRootSignature() const {
     return RootSignature;
   }
 

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

@@ -17,6 +17,7 @@
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/Object/DXContainer.h"
 #include "llvm/ObjectYAML/YAML.h"
 #include "llvm/Support/YAMLTraits.h"
 #include <array>
@@ -75,7 +76,7 @@ struct ShaderHash {
 #define ROOT_ELEMENT_FLAG(Num, Val, Str) bool Val = false;
 struct RootSignatureDesc {
   RootSignatureDesc() = default;
-  RootSignatureDesc(const dxbc::RootSignatureDesc &Data);
+  RootSignatureDesc(const object::DirectX::RootSignature &Data);
 
   uint32_t getEncodedFlags();
   uint32_t Version;

llvm/lib/MC/CMakeLists.txt

@@ -1,6 +1,7 @@
 add_llvm_component_library(LLVMMC
   ConstantPools.cpp
   DXContainerPSVInfo.cpp
+  DXContainerRootSignature.cpp
   ELFObjectWriter.cpp
   GOFFObjectWriter.cpp
   MCAsmBackend.cpp

llvm/lib/MC/DXContainerRootSignature.cpp

@@ -0,0 +1,29 @@
+//===- llvm/MC/DXContainerRootSignature.cpp - DXContainer RootSignature -*- C++
+//-------*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/DXContainerRootSignature.h"
+#include "llvm/Support/EndianStream.h"
+#include "llvm/Support/SwapByteOrder.h"
+#include <iterator>
+
+using namespace llvm;
+using namespace llvm::mcdxbc;
+
+void RootSignatureHeader::write(raw_ostream &OS, uint32_t Version) {
+
+  uint32_t SizeInfo = sizeof(this);
+  // support::endian::write(OS, SizeInfo, llvm::endianness::little);
+
+  if (sys::IsBigEndianHost) {
+    sys::swapByteOrder(Version);
+    sys::swapByteOrder(Flags);
+  }
+
+  OS.write(reinterpret_cast<const char *>(this), SizeInfo);
+}

llvm/lib/Object/DXContainer.cpp

@@ -95,8 +95,8 @@ Error DXContainer::parseHash(StringRef Part) {
 Error DXContainer::parseRootSignature(StringRef Part) {
   if (RootSignature)
     return parseFailed("More than one RTS0 part is present in the file");
-  dxbc::RootSignatureDesc Desc;
-  if (Error Err = readStruct(Part, Part.begin(), Desc))
+  DirectX::RootSignature Desc(Part);
+  if (Error Err = Desc.parse())
     return Err;
   RootSignature = Desc;
   return Error::success();
@@ -242,6 +242,20 @@ void DXContainer::PartIterator::updateIteratorImpl(const uint32_t Offset) {
   IteratorState.Offset = Offset;
 }
 
+Error DirectX::RootSignature::parse() {
+  const char *Current = Data.begin();
+  dxbc::RootSignatureDesc Desc;
+  if (Error Err = readStruct(Data, Current, Desc))
+    return Err;
+
+  if (sys::IsBigEndianHost)
+    Desc.swapBytes();
+
+  Version = Desc.Version;
+  Flags = Desc.Flags;
+  return Error::success();
+}
+
 Error DirectX::PSVRuntimeInfo::parse(uint16_t ShaderKind) {
   Triple::EnvironmentType ShaderStage = dxbc::getShaderStage(ShaderKind);
 

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

@@ -13,6 +13,7 @@
 
 #include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/MC/DXContainerPSVInfo.h"
+#include "llvm/MC/DXContainerRootSignature.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/Errc.h"
@@ -264,13 +265,12 @@ void DXContainerWriter::writeParts(raw_ostream &OS) {
     case dxbc::PartType::RTS0:
       if (!P.RootSignature.has_value())
         continue;
-      uint32_t Flags = P.RootSignature->getEncodedFlags();
-      if (sys::IsBigEndianHost)
-        sys::swapByteOrder(Flags);
-      dxbc::RootSignatureDesc RS = {P.RootSignature->Version, Flags};
-      if (sys::IsBigEndianHost)
-        RS.swapBytes();
-      OS.write(reinterpret_cast<char *>(&RS), sizeof(dxbc::RootSignatureDesc));
+
+      mcdxbc::RootSignatureHeader Header;
+      Header.Version = P.RootSignature->Version;
+      Header.Flags = P.RootSignature->getEncodedFlags();
+
+      Header.write(OS);
       break;
     }
     uint64_t BytesWritten = OS.tell() - DataStart;

llvm/lib/ObjectYAML/DXContainerYAML.cpp

@@ -14,6 +14,7 @@
 #include "llvm/ObjectYAML/DXContainerYAML.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/Object/DXContainer.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <cstdint>
 
@@ -31,10 +32,11 @@ DXContainerYAML::ShaderFeatureFlags::ShaderFeatureFlags(uint64_t FlagData) {
 }
 
 DXContainerYAML::RootSignatureDesc::RootSignatureDesc(
-    const dxbc::RootSignatureDesc &Data)
-    : Version(Data.Version) {
+    const object::DirectX::RootSignature &Data)
+    : Version(Data.getVersion()) {
+  uint32_t Flags = Data.getFlags();
 #define ROOT_ELEMENT_FLAG(Num, Val, Str)                                       \
-  Val = (Data.Flags & (uint32_t)dxbc::RootElementFlag::Val) > 0;
+  Val = (Flags & (uint32_t)dxbc::RootElementFlag::Val) > 0;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 

llvm/tools/obj2yaml/dxcontainer2yaml.cpp

@@ -154,7 +154,7 @@ dumpDXContainer(MemoryBufferRef Source) {
     case dxbc::PartType::Unknown:
       break;
     case dxbc::PartType::RTS0:
-      std::optional<dxbc::RootSignatureDesc> RS = Container.getRootSignature();
+      std::optional<DirectX::RootSignature> RS = Container.getRootSignature();
       if (RS.has_value())
         NewPart.RootSignature = DXContainerYAML::RootSignatureDesc(*RS);
       break;