1 //===- Writer.cpp ---------------------------------------------------------===//
2 //
3 //                      The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "Writer.h"
11 #include "Object.h"
12 #include "llvm-objcopy.h"
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/StringRef.h"
15 #include "llvm/BinaryFormat/COFF.h"
16 #include "llvm/Object/COFF.h"
17 #include "llvm/Support/ErrorHandling.h"
18 #include <cstddef>
19 #include <cstdint>
20 
21 namespace llvm {
22 namespace objcopy {
23 namespace coff {
24 
25 using namespace object;
26 using namespace COFF;
27 
28 Error COFFWriter::finalizeRelocTargets() {
29   for (Section &Sec : Obj.Sections) {
30     for (Relocation &R : Sec.Relocs) {
31       const Symbol *Sym = Obj.findSymbol(R.Target);
32       if (Sym == nullptr)
33         return make_error<StringError>("Relocation target " + R.TargetName +
34                                            " (" + Twine(R.Target) +
35                                            ") not found",
36                                        object_error::invalid_symbol_index);
37       R.Reloc.SymbolTableIndex = Sym->RawIndex;
38     }
39   }
40   return Error::success();
41 }
42 
43 void COFFWriter::layoutSections() {
44   for (auto &S : Obj.Sections) {
45     if (S.Header.SizeOfRawData > 0)
46       S.Header.PointerToRawData = FileSize;
47     FileSize += S.Header.SizeOfRawData; // For executables, this is already
48                                         // aligned to FileAlignment.
49     S.Header.NumberOfRelocations = S.Relocs.size();
50     S.Header.PointerToRelocations =
51         S.Header.NumberOfRelocations > 0 ? FileSize : 0;
52     FileSize += S.Relocs.size() * sizeof(coff_relocation);
53     FileSize = alignTo(FileSize, FileAlignment);
54 
55     if (S.Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
56       SizeOfInitializedData += S.Header.SizeOfRawData;
57   }
58 }
59 
60 size_t COFFWriter::finalizeStringTable() {
61   for (auto &S : Obj.Sections)
62     if (S.Name.size() > COFF::NameSize)
63       StrTabBuilder.add(S.Name);
64 
65   for (const auto &S : Obj.getSymbols())
66     if (S.Name.size() > COFF::NameSize)
67       StrTabBuilder.add(S.Name);
68 
69   StrTabBuilder.finalize();
70 
71   for (auto &S : Obj.Sections) {
72     if (S.Name.size() > COFF::NameSize) {
73       snprintf(S.Header.Name, sizeof(S.Header.Name), "/%d",
74                (int)StrTabBuilder.getOffset(S.Name));
75     } else {
76       strncpy(S.Header.Name, S.Name.data(), COFF::NameSize);
77     }
78   }
79   for (auto &S : Obj.getMutableSymbols()) {
80     if (S.Name.size() > COFF::NameSize) {
81       S.Sym.Name.Offset.Zeroes = 0;
82       S.Sym.Name.Offset.Offset = StrTabBuilder.getOffset(S.Name);
83     } else {
84       strncpy(S.Sym.Name.ShortName, S.Name.data(), COFF::NameSize);
85     }
86   }
87   return StrTabBuilder.getSize();
88 }
89 
90 template <class SymbolTy>
91 std::pair<size_t, size_t> COFFWriter::finalizeSymbolTable() {
92   size_t SymTabSize = Obj.getSymbols().size() * sizeof(SymbolTy);
93   for (const auto &S : Obj.getSymbols())
94     SymTabSize += S.AuxData.size();
95   return std::make_pair(SymTabSize, sizeof(SymbolTy));
96 }
97 
98 Error COFFWriter::finalize(bool IsBigObj) {
99   if (Error E = finalizeRelocTargets())
100     return E;
101 
102   size_t SizeOfHeaders = 0;
103   FileAlignment = 1;
104   size_t PeHeaderSize = 0;
105   if (Obj.IsPE) {
106     Obj.DosHeader.AddressOfNewExeHeader =
107         sizeof(Obj.DosHeader) + Obj.DosStub.size();
108     SizeOfHeaders += Obj.DosHeader.AddressOfNewExeHeader + sizeof(PEMagic);
109 
110     FileAlignment = Obj.PeHeader.FileAlignment;
111     Obj.PeHeader.NumberOfRvaAndSize = Obj.DataDirectories.size();
112 
113     PeHeaderSize = Obj.Is64 ? sizeof(pe32plus_header) : sizeof(pe32_header);
114     SizeOfHeaders +=
115         PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
116   }
117   Obj.CoffFileHeader.NumberOfSections = Obj.Sections.size();
118   SizeOfHeaders +=
119       IsBigObj ? sizeof(coff_bigobj_file_header) : sizeof(coff_file_header);
120   SizeOfHeaders += sizeof(coff_section) * Obj.Sections.size();
121   SizeOfHeaders = alignTo(SizeOfHeaders, FileAlignment);
122 
123   Obj.CoffFileHeader.SizeOfOptionalHeader =
124       PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
125 
126   FileSize = SizeOfHeaders;
127   SizeOfInitializedData = 0;
128 
129   layoutSections();
130 
131   if (Obj.IsPE) {
132     Obj.PeHeader.SizeOfHeaders = SizeOfHeaders;
133     Obj.PeHeader.SizeOfInitializedData = SizeOfInitializedData;
134 
135     if (!Obj.Sections.empty()) {
136       const Section &S = Obj.Sections.back();
137       Obj.PeHeader.SizeOfImage =
138           alignTo(S.Header.VirtualAddress + S.Header.VirtualSize,
139                   Obj.PeHeader.SectionAlignment);
140     }
141 
142     // If the PE header had a checksum, clear it, since it isn't valid
143     // any longer. (We don't calculate a new one.)
144     Obj.PeHeader.CheckSum = 0;
145   }
146 
147   size_t StrTabSize = finalizeStringTable();
148   size_t SymTabSize, SymbolSize;
149   std::tie(SymTabSize, SymbolSize) = IsBigObj
150                                          ? finalizeSymbolTable<coff_symbol32>()
151                                          : finalizeSymbolTable<coff_symbol16>();
152 
153   size_t PointerToSymbolTable = FileSize;
154   // StrTabSize <= 4 is the size of an empty string table, only consisting
155   // of the length field.
156   if (SymTabSize == 0 && StrTabSize <= 4 && Obj.IsPE) {
157     // For executables, don't point to the symbol table and skip writing
158     // the length field, if both the symbol and string tables are empty.
159     PointerToSymbolTable = 0;
160     StrTabSize = 0;
161   }
162 
163   size_t NumRawSymbols = SymTabSize / SymbolSize;
164   Obj.CoffFileHeader.PointerToSymbolTable = PointerToSymbolTable;
165   Obj.CoffFileHeader.NumberOfSymbols = NumRawSymbols;
166   FileSize += SymTabSize + StrTabSize;
167   FileSize = alignTo(FileSize, FileAlignment);
168 
169   return Error::success();
170 }
171 
172 void COFFWriter::writeHeaders(bool IsBigObj) {
173   uint8_t *Ptr = Buf.getBufferStart();
174   if (Obj.IsPE) {
175     memcpy(Ptr, &Obj.DosHeader, sizeof(Obj.DosHeader));
176     Ptr += sizeof(Obj.DosHeader);
177     memcpy(Ptr, Obj.DosStub.data(), Obj.DosStub.size());
178     Ptr += Obj.DosStub.size();
179     memcpy(Ptr, PEMagic, sizeof(PEMagic));
180     Ptr += sizeof(PEMagic);
181   }
182   if (!IsBigObj) {
183     memcpy(Ptr, &Obj.CoffFileHeader, sizeof(Obj.CoffFileHeader));
184     Ptr += sizeof(Obj.CoffFileHeader);
185   } else {
186     // Generate a coff_bigobj_file_header, filling it in with the values
187     // from Obj.CoffFileHeader. All extra fields that don't exist in
188     // coff_file_header can be set to hardcoded values.
189     coff_bigobj_file_header BigObjHeader;
190     BigObjHeader.Sig1 = IMAGE_FILE_MACHINE_UNKNOWN;
191     BigObjHeader.Sig2 = 0xffff;
192     BigObjHeader.Version = BigObjHeader::MinBigObjectVersion;
193     BigObjHeader.Machine = Obj.CoffFileHeader.Machine;
194     BigObjHeader.TimeDateStamp = Obj.CoffFileHeader.TimeDateStamp;
195     memcpy(BigObjHeader.UUID, BigObjMagic, sizeof(BigObjMagic));
196     BigObjHeader.unused1 = 0;
197     BigObjHeader.unused2 = 0;
198     BigObjHeader.unused3 = 0;
199     BigObjHeader.unused4 = 0;
200     // The value in Obj.CoffFileHeader.NumberOfSections is truncated, thus
201     // get the original one instead.
202     BigObjHeader.NumberOfSections = Obj.Sections.size();
203     BigObjHeader.PointerToSymbolTable = Obj.CoffFileHeader.PointerToSymbolTable;
204     BigObjHeader.NumberOfSymbols = Obj.CoffFileHeader.NumberOfSymbols;
205 
206     memcpy(Ptr, &BigObjHeader, sizeof(BigObjHeader));
207     Ptr += sizeof(BigObjHeader);
208   }
209   if (Obj.IsPE) {
210     if (Obj.Is64) {
211       memcpy(Ptr, &Obj.PeHeader, sizeof(Obj.PeHeader));
212       Ptr += sizeof(Obj.PeHeader);
213     } else {
214       pe32_header PeHeader;
215       copyPeHeader(PeHeader, Obj.PeHeader);
216       // The pe32plus_header (stored in Object) lacks the BaseOfData field.
217       PeHeader.BaseOfData = Obj.BaseOfData;
218 
219       memcpy(Ptr, &PeHeader, sizeof(PeHeader));
220       Ptr += sizeof(PeHeader);
221     }
222     for (const auto &DD : Obj.DataDirectories) {
223       memcpy(Ptr, &DD, sizeof(DD));
224       Ptr += sizeof(DD);
225     }
226   }
227   for (const auto &S : Obj.Sections) {
228     memcpy(Ptr, &S.Header, sizeof(S.Header));
229     Ptr += sizeof(S.Header);
230   }
231 }
232 
233 void COFFWriter::writeSections() {
234   for (const auto &S : Obj.Sections) {
235     uint8_t *Ptr = Buf.getBufferStart() + S.Header.PointerToRawData;
236     std::copy(S.Contents.begin(), S.Contents.end(), Ptr);
237 
238     // For executable sections, pad the remainder of the raw data size with
239     // 0xcc, which is int3 on x86.
240     if ((S.Header.Characteristics & IMAGE_SCN_CNT_CODE) &&
241         S.Header.SizeOfRawData > S.Contents.size())
242       memset(Ptr + S.Contents.size(), 0xcc,
243              S.Header.SizeOfRawData - S.Contents.size());
244 
245     Ptr += S.Header.SizeOfRawData;
246     for (const auto &R : S.Relocs) {
247       memcpy(Ptr, &R.Reloc, sizeof(R.Reloc));
248       Ptr += sizeof(R.Reloc);
249     }
250   }
251 }
252 
253 template <class SymbolTy> void COFFWriter::writeSymbolStringTables() {
254   uint8_t *Ptr = Buf.getBufferStart() + Obj.CoffFileHeader.PointerToSymbolTable;
255   for (const auto &S : Obj.getSymbols()) {
256     // Convert symbols back to the right size, from coff_symbol32.
257     copySymbol<SymbolTy, coff_symbol32>(*reinterpret_cast<SymbolTy *>(Ptr),
258                                         S.Sym);
259     Ptr += sizeof(SymbolTy);
260     std::copy(S.AuxData.begin(), S.AuxData.end(), Ptr);
261     Ptr += S.AuxData.size();
262   }
263   if (StrTabBuilder.getSize() > 4 || !Obj.IsPE) {
264     // Always write a string table in object files, even an empty one.
265     StrTabBuilder.write(Ptr);
266     Ptr += StrTabBuilder.getSize();
267   }
268 }
269 
270 Error COFFWriter::write(bool IsBigObj) {
271   if (Error E = finalize(IsBigObj))
272     return E;
273 
274   Buf.allocate(FileSize);
275 
276   writeHeaders(IsBigObj);
277   writeSections();
278   if (IsBigObj)
279     writeSymbolStringTables<coff_symbol32>();
280   else
281     writeSymbolStringTables<coff_symbol16>();
282 
283   if (Obj.IsPE)
284     if (Error E = patchDebugDirectory())
285       return E;
286 
287   return Buf.commit();
288 }
289 
290 // Locate which sections contain the debug directories, iterate over all
291 // the debug_directory structs in there, and set the PointerToRawData field
292 // in all of them, according to their new physical location in the file.
293 Error COFFWriter::patchDebugDirectory() {
294   if (Obj.DataDirectories.size() < DEBUG_DIRECTORY)
295     return Error::success();
296   const data_directory *Dir = &Obj.DataDirectories[DEBUG_DIRECTORY];
297   if (Dir->Size <= 0)
298     return Error::success();
299   for (const auto &S : Obj.Sections) {
300     if (Dir->RelativeVirtualAddress >= S.Header.VirtualAddress &&
301         Dir->RelativeVirtualAddress <
302             S.Header.VirtualAddress + S.Header.SizeOfRawData) {
303       if (Dir->RelativeVirtualAddress + Dir->Size >
304           S.Header.VirtualAddress + S.Header.SizeOfRawData)
305         return make_error<StringError>(
306             "Debug directory extends past end of section",
307             object_error::parse_failed);
308 
309       size_t Offset = Dir->RelativeVirtualAddress - S.Header.VirtualAddress;
310       uint8_t *Ptr = Buf.getBufferStart() + S.Header.PointerToRawData + Offset;
311       uint8_t *End = Ptr + Dir->Size;
312       while (Ptr < End) {
313         debug_directory *Debug = reinterpret_cast<debug_directory *>(Ptr);
314         Debug->PointerToRawData =
315             S.Header.PointerToRawData + Offset + sizeof(debug_directory);
316         Ptr += sizeof(debug_directory) + Debug->SizeOfData;
317         Offset += sizeof(debug_directory) + Debug->SizeOfData;
318       }
319       // Debug directory found and patched, all done.
320       return Error::success();
321     }
322   }
323   return make_error<StringError>("Debug directory not found",
324                                  object_error::parse_failed);
325 }
326 
327 Error COFFWriter::write() {
328   bool IsBigObj = Obj.Sections.size() > MaxNumberOfSections16;
329   if (IsBigObj && Obj.IsPE)
330     return make_error<StringError>("Too many sections for executable",
331                                    object_error::parse_failed);
332   return write(IsBigObj);
333 }
334 
335 } // end namespace coff
336 } // end namespace objcopy
337 } // end namespace llvm
338