Revert "Add support for PSV EntryFunctionName (#84409)"

llvm/include/llvm/BinaryFormat/DXContainer.h

@@ -424,19 +424,6 @@ struct ResourceBindInfo : public v0::ResourceBindInfo {
 };
 
 } // namespace v2
-
-namespace v3 {
-struct RuntimeInfo : public v2::RuntimeInfo {
-  uint32_t EntryNameOffset;
-
-  void swapBytes() { sys::swapByteOrder(EntryNameOffset); }
-
-  void swapBytes(Triple::EnvironmentType Stage) {
-    v2::RuntimeInfo::swapBytes(Stage);
-  }
-};
-
-} // namespace v3
 } // namespace PSV
 
 #define COMPONENT_PRECISION(Val, Enum) Enum = Val,

llvm/include/llvm/MC/DXContainerPSVInfo.h

@@ -9,11 +9,9 @@
 #ifndef LLVM_MC_DXCONTAINERPSVINFO_H
 #define LLVM_MC_DXCONTAINERPSVINFO_H
 
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/DXContainer.h"
-#include "llvm/MC/StringTableBuilder.h"
 #include "llvm/TargetParser/Triple.h"
 
 #include <array>
@@ -47,9 +45,8 @@ struct PSVSignatureElement {
 // modifiable format, and can be used to serialize the data back into valid PSV
 // RuntimeInfo.
 struct PSVRuntimeInfo {
-  PSVRuntimeInfo() : DXConStrTabBuilder(StringTableBuilder::DXContainer) {}
   bool IsFinalized = false;
-  dxbc::PSV::v3::RuntimeInfo BaseData;
+  dxbc::PSV::v2::RuntimeInfo BaseData;
   SmallVector<dxbc::PSV::v2::ResourceBindInfo> Resources;
   SmallVector<PSVSignatureElement> InputElements;
   SmallVector<PSVSignatureElement> OutputElements;
@@ -67,20 +64,26 @@ struct PSVRuntimeInfo {
   std::array<SmallVector<uint32_t>, 4> InputOutputMap;
   SmallVector<uint32_t> InputPatchMap;
   SmallVector<uint32_t> PatchOutputMap;
-  llvm::StringRef EntryName;
 
   // Serialize PSVInfo into the provided raw_ostream. The version field
   // specifies the data version to encode, the default value specifies encoding
   // the highest supported version.
   void write(raw_ostream &OS,
              uint32_t Version = std::numeric_limits<uint32_t>::max()) const;
 
-  void finalize(Triple::EnvironmentType Stage);
-
-private:
-  SmallVector<uint32_t, 64> IndexBuffer;
-  SmallVector<llvm::dxbc::PSV::v0::SignatureElement, 32> SignatureElements;
-  StringTableBuilder DXConStrTabBuilder;
+  void finalize(Triple::EnvironmentType Stage) {
+    IsFinalized = true;
+    BaseData.SigInputElements = static_cast<uint32_t>(InputElements.size());
+    BaseData.SigOutputElements = static_cast<uint32_t>(OutputElements.size());
+    BaseData.SigPatchOrPrimElements =
+        static_cast<uint32_t>(PatchOrPrimElements.size());
+    if (!sys::IsBigEndianHost)
+      return;
+    BaseData.swapBytes();
+    BaseData.swapBytes(Stage);
+    for (auto &Res : Resources)
+      Res.swapBytes();
+  }
 };
 
 class Signature {

llvm/include/llvm/MC/StringTableBuilder.h

@@ -74,8 +74,12 @@ class StringTableBuilder {
   /// Check if a string is contained in the string table. Since this class
   /// doesn't store the string values, this function can be used to check if
   /// storage needs to be done prior to adding the string.
-  bool contains(StringRef S) const { return contains(CachedHashStringRef(S)); }
-  bool contains(CachedHashStringRef S) const { return StringIndexMap.count(S); }
+  bool contains(StringRef S) const {
+    return contains(CachedHashStringRef(S));
+  }
+  bool contains(CachedHashStringRef S) const {
+    return StringIndexMap.count(S);
+  }
 
   size_t getSize() const { return Size; }
   void clear();

llvm/include/llvm/Object/DXContainer.h

@@ -125,8 +125,7 @@ class PSVRuntimeInfo {
   uint32_t Size;
   using InfoStruct =
       std::variant<std::monostate, dxbc::PSV::v0::RuntimeInfo,
-                   dxbc::PSV::v1::RuntimeInfo, dxbc::PSV::v2::RuntimeInfo,
-                   dxbc::PSV::v3::RuntimeInfo>;
+                   dxbc::PSV::v1::RuntimeInfo, dxbc::PSV::v2::RuntimeInfo>;
   InfoStruct BasicInfo;
   ResourceArray Resources;
   StringRef StringTable;
@@ -152,23 +151,16 @@ class PSVRuntimeInfo {
   ResourceArray getResources() const { return Resources; }
 
   uint32_t getVersion() const {
-    return Size >= sizeof(dxbc::PSV::v3::RuntimeInfo)
-               ? 3
-               : (Size >= sizeof(dxbc::PSV::v2::RuntimeInfo)     ? 2
-                  : (Size >= sizeof(dxbc::PSV::v1::RuntimeInfo)) ? 1
-                                                                 : 0);
+    return Size >= sizeof(dxbc::PSV::v2::RuntimeInfo)
+               ? 2
+               : (Size >= sizeof(dxbc::PSV::v1::RuntimeInfo) ? 1 : 0);
   }
 
   uint32_t getResourceStride() const { return Resources.Stride; }
 
   const InfoStruct &getInfo() const { return BasicInfo; }
 
   template <typename T> const T *getInfoAs() const {
-    if (const auto *P = std::get_if<dxbc::PSV::v3::RuntimeInfo>(&BasicInfo))
-      return static_cast<const T *>(P);
-    if (std::is_same<T, dxbc::PSV::v3::RuntimeInfo>::value)
-      return nullptr;
-
     if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
       return static_cast<const T *>(P);
     if (std::is_same<T, dxbc::PSV::v2::RuntimeInfo>::value)

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

@@ -107,7 +107,7 @@ struct PSVInfo {
   // the format.
   uint32_t Version;
 
-  dxbc::PSV::v3::RuntimeInfo Info;
+  dxbc::PSV::v2::RuntimeInfo Info;
   uint32_t ResourceStride;
   SmallVector<ResourceBindInfo> Resources;
   SmallVector<SignatureElement> SigInputElements;
@@ -121,15 +121,12 @@ struct PSVInfo {
   MaskVector InputPatchMap;
   MaskVector PatchOutputMap;
 
-  StringRef EntryName;
-
   void mapInfoForVersion(yaml::IO &IO);
 
   PSVInfo();
   PSVInfo(const dxbc::PSV::v0::RuntimeInfo *P, uint16_t Stage);
   PSVInfo(const dxbc::PSV::v1::RuntimeInfo *P);
   PSVInfo(const dxbc::PSV::v2::RuntimeInfo *P);
-  PSVInfo(const dxbc::PSV::v3::RuntimeInfo *P, StringRef StringTable);
 };
 
 struct SignatureParameter {

llvm/lib/MC/DXContainerPSVInfo.cpp

@@ -81,18 +81,13 @@ void PSVRuntimeInfo::write(raw_ostream &OS, uint32_t Version) const {
     BindingSize = sizeof(dxbc::PSV::v0::ResourceBindInfo);
     break;
   case 2:
-    InfoSize = sizeof(dxbc::PSV::v2::RuntimeInfo);
-    BindingSize = sizeof(dxbc::PSV::v2::ResourceBindInfo);
-    break;
-  case 3:
   default:
-    InfoSize = sizeof(dxbc::PSV::v3::RuntimeInfo);
+    InfoSize = sizeof(dxbc::PSV::v2::RuntimeInfo);
     BindingSize = sizeof(dxbc::PSV::v2::ResourceBindInfo);
   }
-
   // Write the size of the info.
-  support::endian::write(OS, InfoSize, llvm::endianness::little);
 
+  support::endian::write(OS, InfoSize, llvm::endianness::little);
   // Write the info itself.
   OS.write(reinterpret_cast<const char *>(&BaseData), InfoSize);
 
@@ -109,12 +104,32 @@ void PSVRuntimeInfo::write(raw_ostream &OS, uint32_t Version) const {
   if (Version == 0)
     return;
 
-  support::endian::write(OS,
-                         static_cast<uint32_t>(DXConStrTabBuilder.getSize()),
+  StringTableBuilder StrTabBuilder((StringTableBuilder::DXContainer));
+  SmallVector<uint32_t, 64> IndexBuffer;
+  SmallVector<v0::SignatureElement, 32> SignatureElements;
+  SmallVector<StringRef, 32> SemanticNames;
+
+  ProcessElementList(StrTabBuilder, IndexBuffer, SignatureElements,
+                     SemanticNames, InputElements);
+  ProcessElementList(StrTabBuilder, IndexBuffer, SignatureElements,
+                     SemanticNames, OutputElements);
+  ProcessElementList(StrTabBuilder, IndexBuffer, SignatureElements,
+                     SemanticNames, PatchOrPrimElements);
+
+  StrTabBuilder.finalize();
+  for (auto ElAndName : zip(SignatureElements, SemanticNames)) {
+    v0::SignatureElement &El = std::get<0>(ElAndName);
+    StringRef Name = std::get<1>(ElAndName);
+    El.NameOffset = static_cast<uint32_t>(StrTabBuilder.getOffset(Name));
+    if (sys::IsBigEndianHost)
+      El.swapBytes();
+  }
+
+  support::endian::write(OS, static_cast<uint32_t>(StrTabBuilder.getSize()),
                          llvm::endianness::little);
 
   // Write the string table.
-  DXConStrTabBuilder.write(OS);
+  StrTabBuilder.write(OS);
 
   // Write the index table size, then table.
   support::endian::write(OS, static_cast<uint32_t>(IndexBuffer.size()),
@@ -147,46 +162,6 @@ void PSVRuntimeInfo::write(raw_ostream &OS, uint32_t Version) const {
                                llvm::endianness::little);
 }
 
-void PSVRuntimeInfo::finalize(Triple::EnvironmentType Stage) {
-  IsFinalized = true;
-  BaseData.SigInputElements = static_cast<uint32_t>(InputElements.size());
-  BaseData.SigOutputElements = static_cast<uint32_t>(OutputElements.size());
-  BaseData.SigPatchOrPrimElements =
-      static_cast<uint32_t>(PatchOrPrimElements.size());
-
-  SmallVector<StringRef, 32> SemanticNames;
-
-  // Build a string table and set associated offsets to be written when
-  // write() is called
-  ProcessElementList(DXConStrTabBuilder, IndexBuffer, SignatureElements,
-                     SemanticNames, InputElements);
-  ProcessElementList(DXConStrTabBuilder, IndexBuffer, SignatureElements,
-                     SemanticNames, OutputElements);
-  ProcessElementList(DXConStrTabBuilder, IndexBuffer, SignatureElements,
-                     SemanticNames, PatchOrPrimElements);
-
-  DXConStrTabBuilder.add(EntryName);
-
-  DXConStrTabBuilder.finalize();
-  for (auto ElAndName : zip(SignatureElements, SemanticNames)) {
-    llvm::dxbc::PSV::v0::SignatureElement &El = std::get<0>(ElAndName);
-    StringRef Name = std::get<1>(ElAndName);
-    El.NameOffset = static_cast<uint32_t>(DXConStrTabBuilder.getOffset(Name));
-    if (sys::IsBigEndianHost)
-      El.swapBytes();
-  }
-
-  BaseData.EntryNameOffset =
-      static_cast<uint32_t>(DXConStrTabBuilder.getOffset(EntryName));
-
-  if (!sys::IsBigEndianHost)
-    return;
-  BaseData.swapBytes();
-  BaseData.swapBytes(Stage);
-  for (auto &Res : Resources)
-    Res.swapBytes();
-}
-
 void Signature::write(raw_ostream &OS) {
   SmallVector<dxbc::ProgramSignatureElement> SigParams;
   SigParams.reserve(Params.size());

llvm/lib/Object/DXContainer.cpp

@@ -247,14 +247,7 @@ Error DirectX::PSVRuntimeInfo::parse(uint16_t ShaderKind) {
   const uint32_t PSVVersion = getVersion();
 
   // Detect the PSVVersion by looking at the size field.
-  if (PSVVersion == 3) {
-    v3::RuntimeInfo Info;
-    if (Error Err = readStruct(PSVInfoData, Current, Info))
-      return Err;
-    if (sys::IsBigEndianHost)
-      Info.swapBytes(ShaderStage);
-    BasicInfo = Info;
-  } else if (PSVVersion == 2) {
+  if (PSVVersion == 2) {
     v2::RuntimeInfo Info;
     if (Error Err = readStruct(PSVInfoData, Current, Info))
       return Err;
@@ -432,8 +425,6 @@ Error DirectX::PSVRuntimeInfo::parse(uint16_t ShaderKind) {
 }
 
 uint8_t DirectX::PSVRuntimeInfo::getSigInputCount() const {
-  if (const auto *P = std::get_if<dxbc::PSV::v3::RuntimeInfo>(&BasicInfo))
-    return P->SigInputElements;
   if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
     return P->SigInputElements;
   if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
@@ -442,8 +433,6 @@ uint8_t DirectX::PSVRuntimeInfo::getSigInputCount() const {
 }
 
 uint8_t DirectX::PSVRuntimeInfo::getSigOutputCount() const {
-  if (const auto *P = std::get_if<dxbc::PSV::v3::RuntimeInfo>(&BasicInfo))
-    return P->SigOutputElements;
   if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
     return P->SigOutputElements;
   if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
@@ -452,8 +441,6 @@ uint8_t DirectX::PSVRuntimeInfo::getSigOutputCount() const {
 }
 
 uint8_t DirectX::PSVRuntimeInfo::getSigPatchOrPrimCount() const {
-  if (const auto *P = std::get_if<dxbc::PSV::v3::RuntimeInfo>(&BasicInfo))
-    return P->SigPatchOrPrimElements;
   if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
     return P->SigPatchOrPrimElements;
   if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

@@ -198,9 +198,8 @@ void DXContainerWriter::writeParts(raw_ostream &OS) {
       if (!P.Info.has_value())
         continue;
       mcdxbc::PSVRuntimeInfo PSV;
-      memcpy(&PSV.BaseData, &P.Info->Info, sizeof(dxbc::PSV::v3::RuntimeInfo));
+      memcpy(&PSV.BaseData, &P.Info->Info, sizeof(dxbc::PSV::v2::RuntimeInfo));
       PSV.Resources = P.Info->Resources;
-      PSV.EntryName = P.Info->EntryName;
 
       for (auto El : P.Info->SigInputElements)
         PSV.InputElements.push_back(mcdxbc::PSVSignatureElement{

llvm/lib/ObjectYAML/DXContainerYAML.cpp

@@ -74,16 +74,6 @@ DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v2::RuntimeInfo *P)
   memcpy(&Info, P, sizeof(dxbc::PSV::v2::RuntimeInfo));
 }
 
-DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v3::RuntimeInfo *P,
-                                  StringRef StringTable)
-    : Version(3),
-      EntryName(StringTable.substr(P->EntryNameOffset,
-                                   StringTable.find('\0', P->EntryNameOffset) -
-                                       P->EntryNameOffset)) {
-  memset(&Info, 0, sizeof(Info));
-  memcpy(&Info, P, sizeof(dxbc::PSV::v3::RuntimeInfo));
-}
-
 namespace yaml {
 
 void MappingTraits<DXContainerYAML::VersionTuple>::mapping(
@@ -358,11 +348,6 @@ void DXContainerYAML::PSVInfo::mapInfoForVersion(yaml::IO &IO) {
   IO.mapRequired("NumThreadsX", Info.NumThreadsX);
   IO.mapRequired("NumThreadsY", Info.NumThreadsY);
   IO.mapRequired("NumThreadsZ", Info.NumThreadsZ);
-
-  if (Version == 2)
-    return;
-
-  IO.mapRequired("EntryName", EntryName);
 }
 
 } // namespace llvm