DXContainerInfo.h

Go to the documentation of this file.

//===----- llvm/MC/DXContainerInfo.h - DXContainer Info ---------*- 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
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_MC_DXCONTAINERINFO_H
#define LLVM_MC_DXCONTAINERINFO_H
 
#include "llvm/ADT/SmallString.h"
#include "llvm/BinaryFormat/DXContainer.h"
 
namespace llvm {
 
class raw_ostream;
 
namespace mcdxbc {
 
struct DebugName {
  dxbc::DebugNameHeader Parameters;
  StringRef Filename;
 
  DebugName() { Parameters.Flags = 0; }
  DebugName(dxbc::DebugNameHeader &Parameters, StringRef Filename)
      : Parameters(Parameters), Filename(Filename) {}
 
  void setFilename(StringRef DebugFilename);
  void write(raw_ostream &OS) const;
};
 
struct CompilerVersion {
  dxbc::CompilerVersionHeader Parameters;
  StringRef CommitSha;
  StringRef CustomVersionString;
 
  CompilerVersion();
 
  void setCommitSha(StringRef CommitSha);
  void setVersionString(StringRef VersionString);
  void write(raw_ostream &OS) const;
 
private:
  void updateContentSize();
};
 
struct SourceInfo {
  struct Section {
    dxbc::SourceInfo::SectionHeader GenericHeader;
 
    void computeGenericHeader(uint32_t ContentSize,
                              dxbc::SourceInfo::SectionType Type);
  };
 
  struct SourceContents : public Section {
    struct Entry {
      dxbc::SourceInfo::Contents::Entry Parameters;
      std::string FileContent;
 
      /// Compute Parameters based on FileContent.
      void compute();
    };
 
    dxbc::SourceInfo::Contents::Header Parameters;
    SmallVector<Entry> Entries;
 
    /// Compute Parameters based on the content of Args.
    /// Sizes are computed assuming CompressionType == None.
    void computeUncompressed(dxbc::SourceInfo::Contents::CompressionType Type);
    /// Update Parameters based on the compressed size of section content.
    void computeFinalSize(uint32_t CompressedSize);
  };
 
  struct SourceNames : public Section {
    struct Header {
      uint32_t Flags;
      uint32_t Count;
      uint16_t EntriesSizeInBytes;
 
      Header() {}
      Header(const dxbc::SourceInfo::Names::HeaderOnDisk &H);
 
      void swapBytes() {
        sys::swapByteOrder(Flags);
        sys::swapByteOrder(Count);
        sys::swapByteOrder(EntriesSizeInBytes);
      }
    };
 
    struct Entry {
      dxbc::SourceInfo::Names::Entry Parameters;
      StringRef FileName;
 
      /// Compute Parameters based on FileName and FileContent.
      void compute(uint32_t ContentSize);
    };
 
    Header Parameters;
    SmallVector<Entry> Entries;
 
    /// Compute headers based on the content of entries.
    void compute();
  };
 
  struct ProgramArgs : public Section {
    using Entry = std::pair<StringRef, StringRef>;
 
    dxbc::SourceInfo::Args::Header Parameters;
    SmallVector<Entry> Args;
 
    /// Compute Parameters based on Args.
    void compute();
  };
 
  dxbc::SourceInfo::Header Parameters;
  SourceNames Names;
  SourceContents Contents;
  ProgramArgs Args;
 
  /// Compute Parameters based on the content of sections.
  void compute();
};
 
/// This data structure is a helper for reading and writing SourceInfo data.
/// This structure is used to represent the extracted data in an inspectable and
/// modifiable format, and can be used to serialize the data back into valid
/// SourceInfo.
struct SourceInfoBuilder {
  bool IsFilled = false;
  bool IsFinalized = false;
  SourceInfo BaseData;
  SmallString<128> CompressedContents;
 
  void setCompressionType(dxbc::SourceInfo::Contents::CompressionType Type) {
    CompressionType = Type;
  }
 
  void addFile(StringRef Name, StringRef Content) {
    FileNamesAndContents.emplace_back(Name, Content);
  }
  void addArg(StringRef Name, StringRef Value) {
    Args.emplace_back(Name, Value);
  }
 
  void computeEntries();
  void finalize();
  void write(raw_ostream &OS) const;
 
private:
  std::optional<dxbc::SourceInfo::Contents::CompressionType> CompressionType;
  SmallVector<std::pair<StringRef, StringRef>> FileNamesAndContents;
  SmallVector<std::pair<StringRef, StringRef>> Args;
 
  void recomputeAfterCompression(uint32_t CompressedSize);
};
 
} // namespace mcdxbc
} // namespace llvm
 
#endif // LLVM_MC_DXCONTAINERINFO_H