1//===- llvm/MC/MCDXContainerWriter.cpp - DXContainer Writer -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "llvm/MC/MCDXContainerWriter.h"
10#include "llvm/BinaryFormat/DXContainer.h"
11#include "llvm/MC/MCAsmLayout.h"
12#include "llvm/MC/MCAssembler.h"
13#include "llvm/MC/MCContext.h"
14#include "llvm/MC/MCSection.h"
15#include "llvm/MC/MCValue.h"
16#include "llvm/Support/Alignment.h"
17#include "llvm/Support/EndianStream.h"
18
19using namespace llvm;
20
21MCDXContainerTargetWriter::~MCDXContainerTargetWriter() {}
22
23namespace {
24class DXContainerObjectWriter : public MCObjectWriter {
25 ::support::endian::Writer W;
26
27 /// The target specific DXContainer writer instance.
28 std::unique_ptr<MCDXContainerTargetWriter> TargetObjectWriter;
29
30public:
31 DXContainerObjectWriter(std::unique_ptr<MCDXContainerTargetWriter> MOTW,
32 raw_pwrite_stream &OS)
33 : W(OS, llvm::endianness::little), TargetObjectWriter(std::move(MOTW)) {}
34
35 ~DXContainerObjectWriter() override {}
36
37private:
38 void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
39 const MCFragment *Fragment, const MCFixup &Fixup,
40 MCValue Target, uint64_t &FixedValue) override {}
41
42 void executePostLayoutBinding(MCAssembler &Asm,
43 const MCAsmLayout &Layout) override {}
44
45 uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
46};
47} // namespace
48
49uint64_t DXContainerObjectWriter::writeObject(MCAssembler &Asm,
50 const MCAsmLayout &Layout) {
51 // Start the file size as the header plus the size of the part offsets.
52 // Presently DXContainer files usually contain 7-10 parts. Reserving space for
53 // 16 part offsets gives us a little room for growth.
54 llvm::SmallVector<uint64_t, 16> PartOffsets;
55 uint64_t PartOffset = 0;
56 for (const MCSection &Sec : Asm) {
57 uint64_t SectionSize = Layout.getSectionAddressSize(Sec: &Sec);
58 // Skip empty sections.
59 if (SectionSize == 0)
60 continue;
61
62 assert(SectionSize < std::numeric_limits<uint32_t>::max() &&
63 "Section size too large for DXContainer");
64
65 PartOffsets.push_back(Elt: PartOffset);
66 PartOffset += sizeof(dxbc::PartHeader) + SectionSize;
67 PartOffset = alignTo(Size: PartOffset, A: Align(4ul));
68 // The DXIL part also writes a program header, so we need to include its
69 // size when computing the offset for a part after the DXIL part.
70 if (Sec.getName() == "DXIL")
71 PartOffset += sizeof(dxbc::ProgramHeader);
72 }
73 assert(PartOffset < std::numeric_limits<uint32_t>::max() &&
74 "Part data too large for DXContainer");
75
76 uint64_t PartStart =
77 sizeof(dxbc::Header) + (PartOffsets.size() * sizeof(uint32_t));
78 uint64_t FileSize = PartStart + PartOffset;
79 assert(FileSize < std::numeric_limits<uint32_t>::max() &&
80 "File size too large for DXContainer");
81
82 // Write the header.
83 W.write<char>(Val: {'D', 'X', 'B', 'C'});
84 // Write 16-bytes of 0's for the hash.
85 W.OS.write_zeros(NumZeros: 16);
86 // Write 1.0 for file format version.
87 W.write<uint16_t>(Val: 1u);
88 W.write<uint16_t>(Val: 0u);
89 // Write the file size.
90 W.write<uint32_t>(Val: static_cast<uint32_t>(FileSize));
91 // Write the number of parts.
92 W.write<uint32_t>(Val: static_cast<uint32_t>(PartOffsets.size()));
93 // Write the offsets for the part headers for each part.
94 for (uint64_t Offset : PartOffsets)
95 W.write<uint32_t>(Val: static_cast<uint32_t>(PartStart + Offset));
96
97 for (const MCSection &Sec : Asm) {
98 uint64_t SectionSize = Layout.getSectionAddressSize(Sec: &Sec);
99 // Skip empty sections.
100 if (SectionSize == 0)
101 continue;
102
103 unsigned Start = W.OS.tell();
104 // Write section header.
105 W.write<char>(Val: ArrayRef<char>(Sec.getName().data(), 4));
106
107 uint64_t PartSize = SectionSize;
108
109 if (Sec.getName() == "DXIL")
110 PartSize += sizeof(dxbc::ProgramHeader);
111 // DXContainer parts should be 4-byte aligned.
112 PartSize = alignTo(Size: PartSize, A: Align(4));
113 W.write<uint32_t>(Val: static_cast<uint32_t>(PartSize));
114 if (Sec.getName() == "DXIL") {
115 dxbc::ProgramHeader Header;
116 memset(s: reinterpret_cast<void *>(&Header), c: 0, n: sizeof(dxbc::ProgramHeader));
117
118 const Triple &TT = Asm.getContext().getTargetTriple();
119 VersionTuple Version = TT.getOSVersion();
120 Header.MajorVersion = static_cast<uint8_t>(Version.getMajor());
121 if (Version.getMinor())
122 Header.MinorVersion = static_cast<uint8_t>(*Version.getMinor());
123 if (TT.hasEnvironment())
124 Header.ShaderKind =
125 static_cast<uint16_t>(TT.getEnvironment() - Triple::Pixel);
126
127 // The program header's size field is in 32-bit words.
128 Header.Size = (SectionSize + sizeof(dxbc::ProgramHeader) + 3) / 4;
129 memcpy(dest: Header.Bitcode.Magic, src: "DXIL", n: 4);
130 Header.Bitcode.Offset = sizeof(dxbc::BitcodeHeader);
131 Header.Bitcode.Size = SectionSize;
132 if (sys::IsBigEndianHost)
133 Header.swapBytes();
134 W.write<char>(Val: ArrayRef<char>(reinterpret_cast<char *>(&Header),
135 sizeof(dxbc::ProgramHeader)));
136 }
137 Asm.writeSectionData(OS&: W.OS, Section: &Sec, Layout);
138 unsigned Size = W.OS.tell() - Start;
139 W.OS.write_zeros(NumZeros: offsetToAlignment(Value: Size, Alignment: Align(4)));
140 }
141 return 0;
142}
143
144std::unique_ptr<MCObjectWriter> llvm::createDXContainerObjectWriter(
145 std::unique_ptr<MCDXContainerTargetWriter> MOTW, raw_pwrite_stream &OS) {
146 return std::make_unique<DXContainerObjectWriter>(args: std::move(MOTW), args&: OS);
147}
148

source code of llvm/lib/MC/MCDXContainerWriter.cpp