1 //===- Writer.cpp ---------------------------------------------------------===//
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 "Writer.h"
10 #include "Object.h"
11 #include "llvm/ADT/ArrayRef.h"
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/BinaryFormat/COFF.h"
14 #include "llvm/Object/COFF.h"
15 #include "llvm/Support/Errc.h"
16 #include "llvm/Support/ErrorHandling.h"
17 #include <cstddef>
18 #include <cstdint>
19
20 namespace llvm {
21 namespace objcopy {
22 namespace coff {
23
24 using namespace object;
25 using namespace COFF;
26
finalizeRelocTargets()27 Error COFFWriter::finalizeRelocTargets() {
28 for (Section &Sec : Obj.getMutableSections()) {
29 for (Relocation &R : Sec.Relocs) {
30 const Symbol *Sym = Obj.findSymbol(R.Target);
31 if (Sym == nullptr)
32 return createStringError(object_error::invalid_symbol_index,
33 "relocation target '%s' (%zu) not found",
34 R.TargetName.str().c_str(), R.Target);
35 R.Reloc.SymbolTableIndex = Sym->RawIndex;
36 }
37 }
38 return Error::success();
39 }
40
finalizeSymbolContents()41 Error COFFWriter::finalizeSymbolContents() {
42 for (Symbol &Sym : Obj.getMutableSymbols()) {
43 if (Sym.TargetSectionId <= 0) {
44 // Undefined, or a special kind of symbol. These negative values
45 // are stored in the SectionNumber field which is unsigned.
46 Sym.Sym.SectionNumber = static_cast<uint32_t>(Sym.TargetSectionId);
47 } else {
48 const Section *Sec = Obj.findSection(Sym.TargetSectionId);
49 if (Sec == nullptr)
50 return createStringError(object_error::invalid_symbol_index,
51 "symbol '%s' points to a removed section",
52 Sym.Name.str().c_str());
53 Sym.Sym.SectionNumber = Sec->Index;
54
55 if (Sym.Sym.NumberOfAuxSymbols == 1 &&
56 Sym.Sym.StorageClass == IMAGE_SYM_CLASS_STATIC) {
57 coff_aux_section_definition *SD =
58 reinterpret_cast<coff_aux_section_definition *>(
59 Sym.AuxData[0].Opaque);
60 uint32_t SDSectionNumber;
61 if (Sym.AssociativeComdatTargetSectionId == 0) {
62 // Not a comdat associative section; just set the Number field to
63 // the number of the section itself.
64 SDSectionNumber = Sec->Index;
65 } else {
66 Sec = Obj.findSection(Sym.AssociativeComdatTargetSectionId);
67 if (Sec == nullptr)
68 return createStringError(
69 object_error::invalid_symbol_index,
70 "symbol '%s' is associative to a removed section",
71 Sym.Name.str().c_str());
72 SDSectionNumber = Sec->Index;
73 }
74 // Update the section definition with the new section number.
75 SD->NumberLowPart = static_cast<uint16_t>(SDSectionNumber);
76 SD->NumberHighPart = static_cast<uint16_t>(SDSectionNumber >> 16);
77 }
78 }
79 // Check that we actually have got AuxData to match the weak symbol target
80 // we want to set. Only >= 1 would be required, but only == 1 makes sense.
81 if (Sym.WeakTargetSymbolId && Sym.Sym.NumberOfAuxSymbols == 1) {
82 coff_aux_weak_external *WE =
83 reinterpret_cast<coff_aux_weak_external *>(Sym.AuxData[0].Opaque);
84 const Symbol *Target = Obj.findSymbol(*Sym.WeakTargetSymbolId);
85 if (Target == nullptr)
86 return createStringError(object_error::invalid_symbol_index,
87 "symbol '%s' is missing its weak target",
88 Sym.Name.str().c_str());
89 WE->TagIndex = Target->RawIndex;
90 }
91 }
92 return Error::success();
93 }
94
layoutSections()95 void COFFWriter::layoutSections() {
96 for (auto &S : Obj.getMutableSections()) {
97 if (S.Header.SizeOfRawData > 0)
98 S.Header.PointerToRawData = FileSize;
99 FileSize += S.Header.SizeOfRawData; // For executables, this is already
100 // aligned to FileAlignment.
101 if (S.Relocs.size() >= 0xffff) {
102 S.Header.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
103 S.Header.NumberOfRelocations = 0xffff;
104 S.Header.PointerToRelocations = FileSize;
105 FileSize += sizeof(coff_relocation);
106 } else {
107 S.Header.NumberOfRelocations = S.Relocs.size();
108 S.Header.PointerToRelocations = S.Relocs.size() ? FileSize : 0;
109 }
110
111 FileSize += S.Relocs.size() * sizeof(coff_relocation);
112 FileSize = alignTo(FileSize, FileAlignment);
113
114 if (S.Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
115 SizeOfInitializedData += S.Header.SizeOfRawData;
116 }
117 }
118
finalizeStringTable()119 size_t COFFWriter::finalizeStringTable() {
120 for (const auto &S : Obj.getSections())
121 if (S.Name.size() > COFF::NameSize)
122 StrTabBuilder.add(S.Name);
123
124 for (const auto &S : Obj.getSymbols())
125 if (S.Name.size() > COFF::NameSize)
126 StrTabBuilder.add(S.Name);
127
128 StrTabBuilder.finalize();
129
130 for (auto &S : Obj.getMutableSections()) {
131 memset(S.Header.Name, 0, sizeof(S.Header.Name));
132 if (S.Name.size() > COFF::NameSize) {
133 snprintf(S.Header.Name, sizeof(S.Header.Name), "/%d",
134 (int)StrTabBuilder.getOffset(S.Name));
135 } else {
136 memcpy(S.Header.Name, S.Name.data(), S.Name.size());
137 }
138 }
139 for (auto &S : Obj.getMutableSymbols()) {
140 if (S.Name.size() > COFF::NameSize) {
141 S.Sym.Name.Offset.Zeroes = 0;
142 S.Sym.Name.Offset.Offset = StrTabBuilder.getOffset(S.Name);
143 } else {
144 strncpy(S.Sym.Name.ShortName, S.Name.data(), COFF::NameSize);
145 }
146 }
147 return StrTabBuilder.getSize();
148 }
149
150 template <class SymbolTy>
finalizeSymbolTable()151 std::pair<size_t, size_t> COFFWriter::finalizeSymbolTable() {
152 size_t RawSymIndex = 0;
153 for (auto &S : Obj.getMutableSymbols()) {
154 // Symbols normally have NumberOfAuxSymbols set correctly all the time.
155 // For file symbols, we need to know the output file's symbol size to be
156 // able to calculate the number of slots it occupies.
157 if (!S.AuxFile.empty())
158 S.Sym.NumberOfAuxSymbols =
159 alignTo(S.AuxFile.size(), sizeof(SymbolTy)) / sizeof(SymbolTy);
160 S.RawIndex = RawSymIndex;
161 RawSymIndex += 1 + S.Sym.NumberOfAuxSymbols;
162 }
163 return std::make_pair(RawSymIndex * sizeof(SymbolTy), sizeof(SymbolTy));
164 }
165
finalize(bool IsBigObj)166 Error COFFWriter::finalize(bool IsBigObj) {
167 size_t SymTabSize, SymbolSize;
168 std::tie(SymTabSize, SymbolSize) = IsBigObj
169 ? finalizeSymbolTable<coff_symbol32>()
170 : finalizeSymbolTable<coff_symbol16>();
171
172 if (Error E = finalizeRelocTargets())
173 return E;
174 if (Error E = finalizeSymbolContents())
175 return E;
176
177 size_t SizeOfHeaders = 0;
178 FileAlignment = 1;
179 size_t PeHeaderSize = 0;
180 if (Obj.IsPE) {
181 Obj.DosHeader.AddressOfNewExeHeader =
182 sizeof(Obj.DosHeader) + Obj.DosStub.size();
183 SizeOfHeaders += Obj.DosHeader.AddressOfNewExeHeader + sizeof(PEMagic);
184
185 FileAlignment = Obj.PeHeader.FileAlignment;
186 Obj.PeHeader.NumberOfRvaAndSize = Obj.DataDirectories.size();
187
188 PeHeaderSize = Obj.Is64 ? sizeof(pe32plus_header) : sizeof(pe32_header);
189 SizeOfHeaders +=
190 PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
191 }
192 Obj.CoffFileHeader.NumberOfSections = Obj.getSections().size();
193 SizeOfHeaders +=
194 IsBigObj ? sizeof(coff_bigobj_file_header) : sizeof(coff_file_header);
195 SizeOfHeaders += sizeof(coff_section) * Obj.getSections().size();
196 SizeOfHeaders = alignTo(SizeOfHeaders, FileAlignment);
197
198 Obj.CoffFileHeader.SizeOfOptionalHeader =
199 PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
200
201 FileSize = SizeOfHeaders;
202 SizeOfInitializedData = 0;
203
204 layoutSections();
205
206 if (Obj.IsPE) {
207 Obj.PeHeader.SizeOfHeaders = SizeOfHeaders;
208 Obj.PeHeader.SizeOfInitializedData = SizeOfInitializedData;
209
210 if (!Obj.getSections().empty()) {
211 const Section &S = Obj.getSections().back();
212 Obj.PeHeader.SizeOfImage =
213 alignTo(S.Header.VirtualAddress + S.Header.VirtualSize,
214 Obj.PeHeader.SectionAlignment);
215 }
216
217 // If the PE header had a checksum, clear it, since it isn't valid
218 // any longer. (We don't calculate a new one.)
219 Obj.PeHeader.CheckSum = 0;
220 }
221
222 size_t StrTabSize = finalizeStringTable();
223
224 size_t PointerToSymbolTable = FileSize;
225 // StrTabSize <= 4 is the size of an empty string table, only consisting
226 // of the length field.
227 if (SymTabSize == 0 && StrTabSize <= 4 && Obj.IsPE) {
228 // For executables, don't point to the symbol table and skip writing
229 // the length field, if both the symbol and string tables are empty.
230 PointerToSymbolTable = 0;
231 StrTabSize = 0;
232 }
233
234 size_t NumRawSymbols = SymTabSize / SymbolSize;
235 Obj.CoffFileHeader.PointerToSymbolTable = PointerToSymbolTable;
236 Obj.CoffFileHeader.NumberOfSymbols = NumRawSymbols;
237 FileSize += SymTabSize + StrTabSize;
238 FileSize = alignTo(FileSize, FileAlignment);
239
240 return Error::success();
241 }
242
writeHeaders(bool IsBigObj)243 void COFFWriter::writeHeaders(bool IsBigObj) {
244 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart());
245 if (Obj.IsPE) {
246 memcpy(Ptr, &Obj.DosHeader, sizeof(Obj.DosHeader));
247 Ptr += sizeof(Obj.DosHeader);
248 memcpy(Ptr, Obj.DosStub.data(), Obj.DosStub.size());
249 Ptr += Obj.DosStub.size();
250 memcpy(Ptr, PEMagic, sizeof(PEMagic));
251 Ptr += sizeof(PEMagic);
252 }
253 if (!IsBigObj) {
254 memcpy(Ptr, &Obj.CoffFileHeader, sizeof(Obj.CoffFileHeader));
255 Ptr += sizeof(Obj.CoffFileHeader);
256 } else {
257 // Generate a coff_bigobj_file_header, filling it in with the values
258 // from Obj.CoffFileHeader. All extra fields that don't exist in
259 // coff_file_header can be set to hardcoded values.
260 coff_bigobj_file_header BigObjHeader;
261 BigObjHeader.Sig1 = IMAGE_FILE_MACHINE_UNKNOWN;
262 BigObjHeader.Sig2 = 0xffff;
263 BigObjHeader.Version = BigObjHeader::MinBigObjectVersion;
264 BigObjHeader.Machine = Obj.CoffFileHeader.Machine;
265 BigObjHeader.TimeDateStamp = Obj.CoffFileHeader.TimeDateStamp;
266 memcpy(BigObjHeader.UUID, BigObjMagic, sizeof(BigObjMagic));
267 BigObjHeader.unused1 = 0;
268 BigObjHeader.unused2 = 0;
269 BigObjHeader.unused3 = 0;
270 BigObjHeader.unused4 = 0;
271 // The value in Obj.CoffFileHeader.NumberOfSections is truncated, thus
272 // get the original one instead.
273 BigObjHeader.NumberOfSections = Obj.getSections().size();
274 BigObjHeader.PointerToSymbolTable = Obj.CoffFileHeader.PointerToSymbolTable;
275 BigObjHeader.NumberOfSymbols = Obj.CoffFileHeader.NumberOfSymbols;
276
277 memcpy(Ptr, &BigObjHeader, sizeof(BigObjHeader));
278 Ptr += sizeof(BigObjHeader);
279 }
280 if (Obj.IsPE) {
281 if (Obj.Is64) {
282 memcpy(Ptr, &Obj.PeHeader, sizeof(Obj.PeHeader));
283 Ptr += sizeof(Obj.PeHeader);
284 } else {
285 pe32_header PeHeader;
286 copyPeHeader(PeHeader, Obj.PeHeader);
287 // The pe32plus_header (stored in Object) lacks the BaseOfData field.
288 PeHeader.BaseOfData = Obj.BaseOfData;
289
290 memcpy(Ptr, &PeHeader, sizeof(PeHeader));
291 Ptr += sizeof(PeHeader);
292 }
293 for (const auto &DD : Obj.DataDirectories) {
294 memcpy(Ptr, &DD, sizeof(DD));
295 Ptr += sizeof(DD);
296 }
297 }
298 for (const auto &S : Obj.getSections()) {
299 memcpy(Ptr, &S.Header, sizeof(S.Header));
300 Ptr += sizeof(S.Header);
301 }
302 }
303
writeSections()304 void COFFWriter::writeSections() {
305 for (const auto &S : Obj.getSections()) {
306 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
307 S.Header.PointerToRawData;
308 ArrayRef<uint8_t> Contents = S.getContents();
309 std::copy(Contents.begin(), Contents.end(), Ptr);
310
311 // For executable sections, pad the remainder of the raw data size with
312 // 0xcc, which is int3 on x86.
313 if ((S.Header.Characteristics & IMAGE_SCN_CNT_CODE) &&
314 S.Header.SizeOfRawData > Contents.size())
315 memset(Ptr + Contents.size(), 0xcc,
316 S.Header.SizeOfRawData - Contents.size());
317
318 Ptr += S.Header.SizeOfRawData;
319
320 if (S.Relocs.size() >= 0xffff) {
321 object::coff_relocation R;
322 R.VirtualAddress = S.Relocs.size() + 1;
323 R.SymbolTableIndex = 0;
324 R.Type = 0;
325 memcpy(Ptr, &R, sizeof(R));
326 Ptr += sizeof(R);
327 }
328 for (const auto &R : S.Relocs) {
329 memcpy(Ptr, &R.Reloc, sizeof(R.Reloc));
330 Ptr += sizeof(R.Reloc);
331 }
332 }
333 }
334
writeSymbolStringTables()335 template <class SymbolTy> void COFFWriter::writeSymbolStringTables() {
336 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
337 Obj.CoffFileHeader.PointerToSymbolTable;
338 for (const auto &S : Obj.getSymbols()) {
339 // Convert symbols back to the right size, from coff_symbol32.
340 copySymbol<SymbolTy, coff_symbol32>(*reinterpret_cast<SymbolTy *>(Ptr),
341 S.Sym);
342 Ptr += sizeof(SymbolTy);
343 if (!S.AuxFile.empty()) {
344 // For file symbols, just write the string into the aux symbol slots,
345 // assuming that the unwritten parts are initialized to zero in the memory
346 // mapped file.
347 std::copy(S.AuxFile.begin(), S.AuxFile.end(), Ptr);
348 Ptr += S.Sym.NumberOfAuxSymbols * sizeof(SymbolTy);
349 } else {
350 // For other auxillary symbols, write their opaque payload into one symbol
351 // table slot each. For big object files, the symbols are larger than the
352 // opaque auxillary symbol struct and we leave padding at the end of each
353 // entry.
354 for (const AuxSymbol &AuxSym : S.AuxData) {
355 ArrayRef<uint8_t> Ref = AuxSym.getRef();
356 std::copy(Ref.begin(), Ref.end(), Ptr);
357 Ptr += sizeof(SymbolTy);
358 }
359 }
360 }
361 if (StrTabBuilder.getSize() > 4 || !Obj.IsPE) {
362 // Always write a string table in object files, even an empty one.
363 StrTabBuilder.write(Ptr);
364 Ptr += StrTabBuilder.getSize();
365 }
366 }
367
write(bool IsBigObj)368 Error COFFWriter::write(bool IsBigObj) {
369 if (Error E = finalize(IsBigObj))
370 return E;
371
372 Buf = WritableMemoryBuffer::getNewMemBuffer(FileSize);
373 if (!Buf)
374 return createStringError(llvm::errc::not_enough_memory,
375 "failed to allocate memory buffer of " +
376 Twine::utohexstr(FileSize) + " bytes.");
377
378 writeHeaders(IsBigObj);
379 writeSections();
380 if (IsBigObj)
381 writeSymbolStringTables<coff_symbol32>();
382 else
383 writeSymbolStringTables<coff_symbol16>();
384
385 if (Obj.IsPE)
386 if (Error E = patchDebugDirectory())
387 return E;
388
389 // TODO: Implement direct writing to the output stream (without intermediate
390 // memory buffer Buf).
391 Out.write(Buf->getBufferStart(), Buf->getBufferSize());
392 return Error::success();
393 }
394
virtualAddressToFileAddress(uint32_t RVA)395 Expected<uint32_t> COFFWriter::virtualAddressToFileAddress(uint32_t RVA) {
396 for (const auto &S : Obj.getSections()) {
397 if (RVA >= S.Header.VirtualAddress &&
398 RVA < S.Header.VirtualAddress + S.Header.SizeOfRawData)
399 return S.Header.PointerToRawData + RVA - S.Header.VirtualAddress;
400 }
401 return createStringError(object_error::parse_failed,
402 "debug directory payload not found");
403 }
404
405 // Locate which sections contain the debug directories, iterate over all
406 // the debug_directory structs in there, and set the PointerToRawData field
407 // in all of them, according to their new physical location in the file.
patchDebugDirectory()408 Error COFFWriter::patchDebugDirectory() {
409 if (Obj.DataDirectories.size() < DEBUG_DIRECTORY)
410 return Error::success();
411 const data_directory *Dir = &Obj.DataDirectories[DEBUG_DIRECTORY];
412 if (Dir->Size <= 0)
413 return Error::success();
414 for (const auto &S : Obj.getSections()) {
415 if (Dir->RelativeVirtualAddress >= S.Header.VirtualAddress &&
416 Dir->RelativeVirtualAddress <
417 S.Header.VirtualAddress + S.Header.SizeOfRawData) {
418 if (Dir->RelativeVirtualAddress + Dir->Size >
419 S.Header.VirtualAddress + S.Header.SizeOfRawData)
420 return createStringError(object_error::parse_failed,
421 "debug directory extends past end of section");
422
423 size_t Offset = Dir->RelativeVirtualAddress - S.Header.VirtualAddress;
424 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
425 S.Header.PointerToRawData + Offset;
426 uint8_t *End = Ptr + Dir->Size;
427 while (Ptr < End) {
428 debug_directory *Debug = reinterpret_cast<debug_directory *>(Ptr);
429 if (!Debug->AddressOfRawData)
430 return createStringError(object_error::parse_failed,
431 "debug directory payload outside of "
432 "mapped sections not supported");
433 if (Expected<uint32_t> FilePosOrErr =
434 virtualAddressToFileAddress(Debug->AddressOfRawData))
435 Debug->PointerToRawData = *FilePosOrErr;
436 else
437 return FilePosOrErr.takeError();
438 Ptr += sizeof(debug_directory);
439 Offset += sizeof(debug_directory);
440 }
441 // Debug directory found and patched, all done.
442 return Error::success();
443 }
444 }
445 return createStringError(object_error::parse_failed,
446 "debug directory not found");
447 }
448
write()449 Error COFFWriter::write() {
450 bool IsBigObj = Obj.getSections().size() > MaxNumberOfSections16;
451 if (IsBigObj && Obj.IsPE)
452 return createStringError(object_error::parse_failed,
453 "too many sections for executable");
454 return write(IsBigObj);
455 }
456
457 } // end namespace coff
458 } // end namespace objcopy
459 } // end namespace llvm
460