1 | //===- lib/MC/GOFFObjectWriter.cpp - GOFF File Writer ---------------------===// |
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 | // This file implements GOFF object file writer information. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "llvm/BinaryFormat/GOFF.h" |
14 | #include "llvm/MC/MCAsmLayout.h" |
15 | #include "llvm/MC/MCAssembler.h" |
16 | #include "llvm/MC/MCGOFFObjectWriter.h" |
17 | #include "llvm/MC/MCValue.h" |
18 | #include "llvm/Support/Debug.h" |
19 | #include "llvm/Support/Endian.h" |
20 | #include "llvm/Support/Path.h" |
21 | #include "llvm/Support/raw_ostream.h" |
22 | |
23 | using namespace llvm; |
24 | |
25 | #define DEBUG_TYPE "goff-writer" |
26 | |
27 | namespace { |
28 | |
29 | // The standard System/390 convention is to name the high-order (leftmost) bit |
30 | // in a byte as bit zero. The Flags type helps to set bits in a byte according |
31 | // to this numeration order. |
32 | class Flags { |
33 | uint8_t Val; |
34 | |
35 | constexpr static uint8_t bits(uint8_t BitIndex, uint8_t Length, uint8_t Value, |
36 | uint8_t OldValue) { |
37 | assert(BitIndex < 8 && "Bit index out of bounds!" ); |
38 | assert(Length + BitIndex <= 8 && "Bit length too long!" ); |
39 | |
40 | uint8_t Mask = ((1 << Length) - 1) << (8 - BitIndex - Length); |
41 | Value = Value << (8 - BitIndex - Length); |
42 | assert((Value & Mask) == Value && "Bits set outside of range!" ); |
43 | |
44 | return (OldValue & ~Mask) | Value; |
45 | } |
46 | |
47 | public: |
48 | constexpr Flags() : Val(0) {} |
49 | constexpr Flags(uint8_t BitIndex, uint8_t Length, uint8_t Value) |
50 | : Val(bits(BitIndex, Length, Value, OldValue: 0)) {} |
51 | |
52 | void set(uint8_t BitIndex, uint8_t Length, uint8_t Value) { |
53 | Val = bits(BitIndex, Length, Value, OldValue: Val); |
54 | } |
55 | |
56 | constexpr operator uint8_t() const { return Val; } |
57 | }; |
58 | |
59 | // Common flag values on records. |
60 | |
61 | // Flag: This record is continued. |
62 | constexpr uint8_t RecContinued = Flags(7, 1, 1); |
63 | |
64 | // Flag: This record is a continuation. |
65 | constexpr uint8_t RecContinuation = Flags(6, 1, 1); |
66 | |
67 | // The GOFFOstream is responsible to write the data into the fixed physical |
68 | // records of the format. A user of this class announces the start of a new |
69 | // logical record and the size of its content. While writing the content, the |
70 | // physical records are created for the data. Possible fill bytes at the end of |
71 | // a physical record are written automatically. In principle, the GOFFOstream |
72 | // is agnostic of the endianness of the content. However, it also supports |
73 | // writing data in big endian byte order. |
74 | class GOFFOstream : public raw_ostream { |
75 | /// The underlying raw_pwrite_stream. |
76 | raw_pwrite_stream &OS; |
77 | |
78 | /// The remaining size of this logical record, including fill bytes. |
79 | size_t RemainingSize; |
80 | |
81 | #ifndef NDEBUG |
82 | /// The number of bytes needed to fill up the last physical record. |
83 | size_t Gap = 0; |
84 | #endif |
85 | |
86 | /// The number of logical records emitted to far. |
87 | uint32_t LogicalRecords; |
88 | |
89 | /// The type of the current (logical) record. |
90 | GOFF::RecordType CurrentType; |
91 | |
92 | /// Signals start of new record. |
93 | bool NewLogicalRecord; |
94 | |
95 | /// Static allocated buffer for the stream, used by the raw_ostream class. The |
96 | /// buffer is sized to hold the content of a physical record. |
97 | char Buffer[GOFF::RecordContentLength]; |
98 | |
99 | // Return the number of bytes left to write until next physical record. |
100 | // Please note that we maintain the total numbers of byte left, not the |
101 | // written size. |
102 | size_t bytesToNextPhysicalRecord() { |
103 | size_t Bytes = RemainingSize % GOFF::RecordContentLength; |
104 | return Bytes ? Bytes : GOFF::RecordContentLength; |
105 | } |
106 | |
107 | /// Write the record prefix of a physical record, using the given record type. |
108 | static void writeRecordPrefix(raw_ostream &OS, GOFF::RecordType Type, |
109 | size_t RemainingSize, |
110 | uint8_t Flags = RecContinuation); |
111 | |
112 | /// Fill the last physical record of a logical record with zero bytes. |
113 | void fillRecord(); |
114 | |
115 | /// See raw_ostream::write_impl. |
116 | void write_impl(const char *Ptr, size_t Size) override; |
117 | |
118 | /// Return the current position within the stream, not counting the bytes |
119 | /// currently in the buffer. |
120 | uint64_t current_pos() const override { return OS.tell(); } |
121 | |
122 | public: |
123 | explicit GOFFOstream(raw_pwrite_stream &OS) |
124 | : OS(OS), RemainingSize(0), LogicalRecords(0), NewLogicalRecord(false) { |
125 | SetBuffer(BufferStart: Buffer, Size: sizeof(Buffer)); |
126 | } |
127 | |
128 | ~GOFFOstream() { finalize(); } |
129 | |
130 | raw_pwrite_stream &getOS() { return OS; } |
131 | |
132 | void newRecord(GOFF::RecordType Type, size_t Size); |
133 | |
134 | void finalize() { fillRecord(); } |
135 | |
136 | uint32_t logicalRecords() { return LogicalRecords; } |
137 | |
138 | // Support for endian-specific data. |
139 | template <typename value_type> void writebe(value_type Value) { |
140 | Value = |
141 | support::endian::byte_swap<value_type>(Value, llvm::endianness::big); |
142 | write(Ptr: reinterpret_cast<const char *>(&Value), Size: sizeof(value_type)); |
143 | } |
144 | }; |
145 | |
146 | void GOFFOstream::writeRecordPrefix(raw_ostream &OS, GOFF::RecordType Type, |
147 | size_t RemainingSize, uint8_t Flags) { |
148 | uint8_t TypeAndFlags = Flags | (Type << 4); |
149 | if (RemainingSize > GOFF::RecordLength) |
150 | TypeAndFlags |= RecContinued; |
151 | OS << static_cast<unsigned char>(GOFF::PTVPrefix) // Record Type |
152 | << static_cast<unsigned char>(TypeAndFlags) // Continuation |
153 | << static_cast<unsigned char>(0); // Version |
154 | } |
155 | |
156 | void GOFFOstream::newRecord(GOFF::RecordType Type, size_t Size) { |
157 | fillRecord(); |
158 | CurrentType = Type; |
159 | RemainingSize = Size; |
160 | #ifdef NDEBUG |
161 | size_t Gap; |
162 | #endif |
163 | Gap = (RemainingSize % GOFF::RecordContentLength); |
164 | if (Gap) { |
165 | Gap = GOFF::RecordContentLength - Gap; |
166 | RemainingSize += Gap; |
167 | } |
168 | NewLogicalRecord = true; |
169 | ++LogicalRecords; |
170 | } |
171 | |
172 | void GOFFOstream::fillRecord() { |
173 | assert((GetNumBytesInBuffer() <= RemainingSize) && |
174 | "More bytes in buffer than expected" ); |
175 | size_t Remains = RemainingSize - GetNumBytesInBuffer(); |
176 | if (Remains) { |
177 | assert(Remains == Gap && "Wrong size of fill gap" ); |
178 | assert((Remains < GOFF::RecordLength) && |
179 | "Attempt to fill more than one physical record" ); |
180 | raw_ostream::write_zeros(NumZeros: Remains); |
181 | } |
182 | flush(); |
183 | assert(RemainingSize == 0 && "Not fully flushed" ); |
184 | assert(GetNumBytesInBuffer() == 0 && "Buffer not fully empty" ); |
185 | } |
186 | |
187 | // This function is called from the raw_ostream implementation if: |
188 | // - The internal buffer is full. Size is excactly the size of the buffer. |
189 | // - Data larger than the internal buffer is written. Size is a multiple of the |
190 | // buffer size. |
191 | // - flush() has been called. Size is at most the buffer size. |
192 | // The GOFFOstream implementation ensures that flush() is called before a new |
193 | // logical record begins. Therefore it is sufficient to check for a new block |
194 | // only once. |
195 | void GOFFOstream::write_impl(const char *Ptr, size_t Size) { |
196 | assert((RemainingSize >= Size) && "Attempt to write too much data" ); |
197 | assert(RemainingSize && "Logical record overflow" ); |
198 | if (!(RemainingSize % GOFF::RecordContentLength)) { |
199 | writeRecordPrefix(OS, Type: CurrentType, RemainingSize, |
200 | Flags: NewLogicalRecord ? 0 : RecContinuation); |
201 | NewLogicalRecord = false; |
202 | } |
203 | assert(!NewLogicalRecord && |
204 | "New logical record not on physical record boundary" ); |
205 | |
206 | size_t Idx = 0; |
207 | while (Size > 0) { |
208 | size_t BytesToWrite = bytesToNextPhysicalRecord(); |
209 | if (BytesToWrite > Size) |
210 | BytesToWrite = Size; |
211 | OS.write(Ptr: Ptr + Idx, Size: BytesToWrite); |
212 | Idx += BytesToWrite; |
213 | Size -= BytesToWrite; |
214 | RemainingSize -= BytesToWrite; |
215 | if (Size) |
216 | writeRecordPrefix(OS, Type: CurrentType, RemainingSize); |
217 | } |
218 | } |
219 | |
220 | class GOFFObjectWriter : public MCObjectWriter { |
221 | // The target specific GOFF writer instance. |
222 | std::unique_ptr<MCGOFFObjectTargetWriter> TargetObjectWriter; |
223 | |
224 | // The stream used to write the GOFF records. |
225 | GOFFOstream OS; |
226 | |
227 | public: |
228 | GOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW, |
229 | raw_pwrite_stream &OS) |
230 | : TargetObjectWriter(std::move(MOTW)), OS(OS) {} |
231 | |
232 | ~GOFFObjectWriter() override {} |
233 | |
234 | // Write GOFF records. |
235 | void writeHeader(); |
236 | void writeEnd(); |
237 | |
238 | // Implementation of the MCObjectWriter interface. |
239 | void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout, |
240 | const MCFragment *Fragment, const MCFixup &Fixup, |
241 | MCValue Target, uint64_t &FixedValue) override {} |
242 | void executePostLayoutBinding(MCAssembler &Asm, |
243 | const MCAsmLayout &Layout) override {} |
244 | uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override; |
245 | }; |
246 | } // end anonymous namespace |
247 | |
248 | void GOFFObjectWriter::() { |
249 | OS.newRecord(Type: GOFF::RT_HDR, /*Size=*/57); |
250 | OS.write_zeros(NumZeros: 1); // Reserved |
251 | OS.writebe<uint32_t>(Value: 0); // Target Hardware Environment |
252 | OS.writebe<uint32_t>(Value: 0); // Target Operating System Environment |
253 | OS.write_zeros(NumZeros: 2); // Reserved |
254 | OS.writebe<uint16_t>(Value: 0); // CCSID |
255 | OS.write_zeros(NumZeros: 16); // Character Set name |
256 | OS.write_zeros(NumZeros: 16); // Language Product Identifier |
257 | OS.writebe<uint32_t>(Value: 1); // Architecture Level |
258 | OS.writebe<uint16_t>(Value: 0); // Module Properties Length |
259 | OS.write_zeros(NumZeros: 6); // Reserved |
260 | } |
261 | |
262 | void GOFFObjectWriter::writeEnd() { |
263 | uint8_t F = GOFF::END_EPR_None; |
264 | uint8_t AMODE = 0; |
265 | uint32_t ESDID = 0; |
266 | |
267 | // TODO Set Flags/AMODE/ESDID for entry point. |
268 | |
269 | OS.newRecord(Type: GOFF::RT_END, /*Size=*/13); |
270 | OS.writebe<uint8_t>(Value: Flags(6, 2, F)); // Indicator flags |
271 | OS.writebe<uint8_t>(Value: AMODE); // AMODE |
272 | OS.write_zeros(NumZeros: 3); // Reserved |
273 | // The record count is the number of logical records. In principle, this value |
274 | // is available as OS.logicalRecords(). However, some tools rely on this field |
275 | // being zero. |
276 | OS.writebe<uint32_t>(Value: 0); // Record Count |
277 | OS.writebe<uint32_t>(Value: ESDID); // ESDID (of entry point) |
278 | OS.finalize(); |
279 | } |
280 | |
281 | uint64_t GOFFObjectWriter::writeObject(MCAssembler &Asm, |
282 | const MCAsmLayout &Layout) { |
283 | uint64_t StartOffset = OS.tell(); |
284 | |
285 | writeHeader(); |
286 | writeEnd(); |
287 | |
288 | LLVM_DEBUG(dbgs() << "Wrote " << OS.logicalRecords() << " logical records." ); |
289 | |
290 | return OS.tell() - StartOffset; |
291 | } |
292 | |
293 | std::unique_ptr<MCObjectWriter> |
294 | llvm::createGOFFObjectWriter(std::unique_ptr<MCGOFFObjectTargetWriter> MOTW, |
295 | raw_pwrite_stream &OS) { |
296 | return std::make_unique<GOFFObjectWriter>(args: std::move(MOTW), args&: OS); |
297 | } |
298 | |