LLVM 19.0.0git
COFFWriter.cpp
Go to the documentation of this file.
1//===- COFFWriter.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 "COFFWriter.h"
10#include "COFFObject.h"
11#include "llvm/ADT/ArrayRef.h"
12#include "llvm/ADT/StringRef.h"
14#include "llvm/Object/COFF.h"
15#include "llvm/Support/Errc.h"
17#include <cstddef>
18#include <cstdint>
19
20namespace llvm {
21namespace objcopy {
22namespace coff {
23
24using namespace object;
25using namespace COFF;
26
27Error 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
41Error 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
95void COFFWriter::layoutSections() {
96 for (auto &S : Obj.getMutableSections()) {
97 if (S.Header.SizeOfRawData > 0)
98 S.Header.PointerToRawData = FileSize;
99 else
100 S.Header.PointerToRawData = 0;
101 FileSize += S.Header.SizeOfRawData; // For executables, this is already
102 // aligned to FileAlignment.
103 if (S.Relocs.size() >= 0xffff) {
104 S.Header.Characteristics |= COFF::IMAGE_SCN_LNK_NRELOC_OVFL;
105 S.Header.NumberOfRelocations = 0xffff;
106 S.Header.PointerToRelocations = FileSize;
107 FileSize += sizeof(coff_relocation);
108 } else {
109 S.Header.NumberOfRelocations = S.Relocs.size();
110 S.Header.PointerToRelocations = S.Relocs.size() ? FileSize : 0;
111 }
112
113 FileSize += S.Relocs.size() * sizeof(coff_relocation);
114 FileSize = alignTo(FileSize, FileAlignment);
115
116 if (S.Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
117 SizeOfInitializedData += S.Header.SizeOfRawData;
118 }
119}
120
121Expected<size_t> COFFWriter::finalizeStringTable() {
122 for (const auto &S : Obj.getSections())
123 if (S.Name.size() > COFF::NameSize)
124 StrTabBuilder.add(S.Name);
125
126 for (const auto &S : Obj.getSymbols())
127 if (S.Name.size() > COFF::NameSize)
128 StrTabBuilder.add(S.Name);
129
130 StrTabBuilder.finalize();
131
132 for (auto &S : Obj.getMutableSections()) {
133 memset(S.Header.Name, 0, sizeof(S.Header.Name));
134 if (S.Name.size() <= COFF::NameSize) {
135 // Short names can go in the field directly.
136 memcpy(S.Header.Name, S.Name.data(), S.Name.size());
137 } else {
138 // Offset of the section name in the string table.
139 size_t Offset = StrTabBuilder.getOffset(S.Name);
140 if (!COFF::encodeSectionName(S.Header.Name, Offset))
141 return createStringError(object_error::invalid_section_index,
142 "COFF string table is greater than 64GB, "
143 "unable to encode section name offset");
144 }
145 }
146 for (auto &S : Obj.getMutableSymbols()) {
147 if (S.Name.size() > COFF::NameSize) {
148 S.Sym.Name.Offset.Zeroes = 0;
149 S.Sym.Name.Offset.Offset = StrTabBuilder.getOffset(S.Name);
150 } else {
151 strncpy(S.Sym.Name.ShortName, S.Name.data(), COFF::NameSize);
152 }
153 }
154 return StrTabBuilder.getSize();
155}
156
157template <class SymbolTy>
158std::pair<size_t, size_t> COFFWriter::finalizeSymbolTable() {
159 size_t RawSymIndex = 0;
160 for (auto &S : Obj.getMutableSymbols()) {
161 // Symbols normally have NumberOfAuxSymbols set correctly all the time.
162 // For file symbols, we need to know the output file's symbol size to be
163 // able to calculate the number of slots it occupies.
164 if (!S.AuxFile.empty())
165 S.Sym.NumberOfAuxSymbols =
166 alignTo(S.AuxFile.size(), sizeof(SymbolTy)) / sizeof(SymbolTy);
167 S.RawIndex = RawSymIndex;
168 RawSymIndex += 1 + S.Sym.NumberOfAuxSymbols;
169 }
170 return std::make_pair(RawSymIndex * sizeof(SymbolTy), sizeof(SymbolTy));
171}
172
173Error COFFWriter::finalize(bool IsBigObj) {
174 size_t SymTabSize, SymbolSize;
175 std::tie(SymTabSize, SymbolSize) = IsBigObj
176 ? finalizeSymbolTable<coff_symbol32>()
177 : finalizeSymbolTable<coff_symbol16>();
178
179 if (Error E = finalizeRelocTargets())
180 return E;
181 if (Error E = finalizeSymbolContents())
182 return E;
183
184 size_t SizeOfHeaders = 0;
185 FileAlignment = 1;
186 size_t PeHeaderSize = 0;
187 if (Obj.IsPE) {
189 sizeof(Obj.DosHeader) + Obj.DosStub.size();
190 SizeOfHeaders += Obj.DosHeader.AddressOfNewExeHeader + sizeof(PEMagic);
191
192 FileAlignment = Obj.PeHeader.FileAlignment;
194
195 PeHeaderSize = Obj.Is64 ? sizeof(pe32plus_header) : sizeof(pe32_header);
196 SizeOfHeaders +=
197 PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
198 }
200 SizeOfHeaders +=
201 IsBigObj ? sizeof(coff_bigobj_file_header) : sizeof(coff_file_header);
202 SizeOfHeaders += sizeof(coff_section) * Obj.getSections().size();
203 SizeOfHeaders = alignTo(SizeOfHeaders, FileAlignment);
204
206 PeHeaderSize + sizeof(data_directory) * Obj.DataDirectories.size();
207
208 FileSize = SizeOfHeaders;
209 SizeOfInitializedData = 0;
210
211 layoutSections();
212
213 if (Obj.IsPE) {
214 Obj.PeHeader.SizeOfHeaders = SizeOfHeaders;
215 Obj.PeHeader.SizeOfInitializedData = SizeOfInitializedData;
216
217 if (!Obj.getSections().empty()) {
218 const Section &S = Obj.getSections().back();
220 alignTo(S.Header.VirtualAddress + S.Header.VirtualSize,
222 }
223
224 // If the PE header had a checksum, clear it, since it isn't valid
225 // any longer. (We don't calculate a new one.)
226 Obj.PeHeader.CheckSum = 0;
227 }
228
229 Expected<size_t> StrTabSizeOrErr = finalizeStringTable();
230 if (!StrTabSizeOrErr)
231 return StrTabSizeOrErr.takeError();
232
233 size_t StrTabSize = *StrTabSizeOrErr;
234
235 size_t PointerToSymbolTable = FileSize;
236 // StrTabSize <= 4 is the size of an empty string table, only consisting
237 // of the length field.
238 if (SymTabSize == 0 && StrTabSize <= 4 && Obj.IsPE) {
239 // For executables, don't point to the symbol table and skip writing
240 // the length field, if both the symbol and string tables are empty.
241 PointerToSymbolTable = 0;
242 StrTabSize = 0;
243 }
244
245 size_t NumRawSymbols = SymTabSize / SymbolSize;
246 Obj.CoffFileHeader.PointerToSymbolTable = PointerToSymbolTable;
247 Obj.CoffFileHeader.NumberOfSymbols = NumRawSymbols;
248 FileSize += SymTabSize + StrTabSize;
249 FileSize = alignTo(FileSize, FileAlignment);
250
251 return Error::success();
252}
253
254void COFFWriter::writeHeaders(bool IsBigObj) {
255 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart());
256 if (Obj.IsPE) {
257 memcpy(Ptr, &Obj.DosHeader, sizeof(Obj.DosHeader));
258 Ptr += sizeof(Obj.DosHeader);
259 memcpy(Ptr, Obj.DosStub.data(), Obj.DosStub.size());
260 Ptr += Obj.DosStub.size();
261 memcpy(Ptr, PEMagic, sizeof(PEMagic));
262 Ptr += sizeof(PEMagic);
263 }
264 if (!IsBigObj) {
265 memcpy(Ptr, &Obj.CoffFileHeader, sizeof(Obj.CoffFileHeader));
266 Ptr += sizeof(Obj.CoffFileHeader);
267 } else {
268 // Generate a coff_bigobj_file_header, filling it in with the values
269 // from Obj.CoffFileHeader. All extra fields that don't exist in
270 // coff_file_header can be set to hardcoded values.
271 coff_bigobj_file_header BigObjHeader;
272 BigObjHeader.Sig1 = IMAGE_FILE_MACHINE_UNKNOWN;
273 BigObjHeader.Sig2 = 0xffff;
274 BigObjHeader.Version = BigObjHeader::MinBigObjectVersion;
275 BigObjHeader.Machine = Obj.CoffFileHeader.Machine;
276 BigObjHeader.TimeDateStamp = Obj.CoffFileHeader.TimeDateStamp;
277 memcpy(BigObjHeader.UUID, BigObjMagic, sizeof(BigObjMagic));
278 BigObjHeader.unused1 = 0;
279 BigObjHeader.unused2 = 0;
280 BigObjHeader.unused3 = 0;
281 BigObjHeader.unused4 = 0;
282 // The value in Obj.CoffFileHeader.NumberOfSections is truncated, thus
283 // get the original one instead.
284 BigObjHeader.NumberOfSections = Obj.getSections().size();
285 BigObjHeader.PointerToSymbolTable = Obj.CoffFileHeader.PointerToSymbolTable;
286 BigObjHeader.NumberOfSymbols = Obj.CoffFileHeader.NumberOfSymbols;
287
288 memcpy(Ptr, &BigObjHeader, sizeof(BigObjHeader));
289 Ptr += sizeof(BigObjHeader);
290 }
291 if (Obj.IsPE) {
292 if (Obj.Is64) {
293 memcpy(Ptr, &Obj.PeHeader, sizeof(Obj.PeHeader));
294 Ptr += sizeof(Obj.PeHeader);
295 } else {
296 pe32_header PeHeader;
297 copyPeHeader(PeHeader, Obj.PeHeader);
298 // The pe32plus_header (stored in Object) lacks the BaseOfData field.
299 PeHeader.BaseOfData = Obj.BaseOfData;
300
301 memcpy(Ptr, &PeHeader, sizeof(PeHeader));
302 Ptr += sizeof(PeHeader);
303 }
304 for (const auto &DD : Obj.DataDirectories) {
305 memcpy(Ptr, &DD, sizeof(DD));
306 Ptr += sizeof(DD);
307 }
308 }
309 for (const auto &S : Obj.getSections()) {
310 memcpy(Ptr, &S.Header, sizeof(S.Header));
311 Ptr += sizeof(S.Header);
312 }
313}
314
315void COFFWriter::writeSections() {
316 for (const auto &S : Obj.getSections()) {
317 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
318 S.Header.PointerToRawData;
319 ArrayRef<uint8_t> Contents = S.getContents();
320 std::copy(Contents.begin(), Contents.end(), Ptr);
321
322 // For executable sections, pad the remainder of the raw data size with
323 // 0xcc, which is int3 on x86.
324 if ((S.Header.Characteristics & IMAGE_SCN_CNT_CODE) &&
325 S.Header.SizeOfRawData > Contents.size())
326 memset(Ptr + Contents.size(), 0xcc,
327 S.Header.SizeOfRawData - Contents.size());
328
329 Ptr += S.Header.SizeOfRawData;
330
331 if (S.Relocs.size() >= 0xffff) {
332 object::coff_relocation R;
333 R.VirtualAddress = S.Relocs.size() + 1;
334 R.SymbolTableIndex = 0;
335 R.Type = 0;
336 memcpy(Ptr, &R, sizeof(R));
337 Ptr += sizeof(R);
338 }
339 for (const auto &R : S.Relocs) {
340 memcpy(Ptr, &R.Reloc, sizeof(R.Reloc));
341 Ptr += sizeof(R.Reloc);
342 }
343 }
344}
345
346template <class SymbolTy> void COFFWriter::writeSymbolStringTables() {
347 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
349 for (const auto &S : Obj.getSymbols()) {
350 // Convert symbols back to the right size, from coff_symbol32.
351 copySymbol<SymbolTy, coff_symbol32>(*reinterpret_cast<SymbolTy *>(Ptr),
352 S.Sym);
353 Ptr += sizeof(SymbolTy);
354 if (!S.AuxFile.empty()) {
355 // For file symbols, just write the string into the aux symbol slots,
356 // assuming that the unwritten parts are initialized to zero in the memory
357 // mapped file.
358 std::copy(S.AuxFile.begin(), S.AuxFile.end(), Ptr);
359 Ptr += S.Sym.NumberOfAuxSymbols * sizeof(SymbolTy);
360 } else {
361 // For other auxillary symbols, write their opaque payload into one symbol
362 // table slot each. For big object files, the symbols are larger than the
363 // opaque auxillary symbol struct and we leave padding at the end of each
364 // entry.
365 for (const AuxSymbol &AuxSym : S.AuxData) {
366 ArrayRef<uint8_t> Ref = AuxSym.getRef();
367 std::copy(Ref.begin(), Ref.end(), Ptr);
368 Ptr += sizeof(SymbolTy);
369 }
370 }
371 }
372 if (StrTabBuilder.getSize() > 4 || !Obj.IsPE) {
373 // Always write a string table in object files, even an empty one.
374 StrTabBuilder.write(Ptr);
375 Ptr += StrTabBuilder.getSize();
376 }
377}
378
379Error COFFWriter::write(bool IsBigObj) {
380 if (Error E = finalize(IsBigObj))
381 return E;
382
384 if (!Buf)
386 "failed to allocate memory buffer of " +
387 Twine::utohexstr(FileSize) + " bytes.");
388
389 writeHeaders(IsBigObj);
390 writeSections();
391 if (IsBigObj)
392 writeSymbolStringTables<coff_symbol32>();
393 else
394 writeSymbolStringTables<coff_symbol16>();
395
396 if (Obj.IsPE)
397 if (Error E = patchDebugDirectory())
398 return E;
399
400 // TODO: Implement direct writing to the output stream (without intermediate
401 // memory buffer Buf).
402 Out.write(Buf->getBufferStart(), Buf->getBufferSize());
403 return Error::success();
404}
405
406Expected<uint32_t> COFFWriter::virtualAddressToFileAddress(uint32_t RVA) {
407 for (const auto &S : Obj.getSections()) {
408 if (RVA >= S.Header.VirtualAddress &&
409 RVA < S.Header.VirtualAddress + S.Header.SizeOfRawData)
410 return S.Header.PointerToRawData + RVA - S.Header.VirtualAddress;
411 }
412 return createStringError(object_error::parse_failed,
413 "debug directory payload not found");
414}
415
416// Locate which sections contain the debug directories, iterate over all
417// the debug_directory structs in there, and set the PointerToRawData field
418// in all of them, according to their new physical location in the file.
419Error COFFWriter::patchDebugDirectory() {
420 if (Obj.DataDirectories.size() <= DEBUG_DIRECTORY)
421 return Error::success();
422 const data_directory *Dir = &Obj.DataDirectories[DEBUG_DIRECTORY];
423 if (Dir->Size <= 0)
424 return Error::success();
425 for (const auto &S : Obj.getSections()) {
426 if (Dir->RelativeVirtualAddress >= S.Header.VirtualAddress &&
427 Dir->RelativeVirtualAddress <
428 S.Header.VirtualAddress + S.Header.SizeOfRawData) {
429 if (Dir->RelativeVirtualAddress + Dir->Size >
430 S.Header.VirtualAddress + S.Header.SizeOfRawData)
431 return createStringError(object_error::parse_failed,
432 "debug directory extends past end of section");
433
434 size_t Offset = Dir->RelativeVirtualAddress - S.Header.VirtualAddress;
435 uint8_t *Ptr = reinterpret_cast<uint8_t *>(Buf->getBufferStart()) +
436 S.Header.PointerToRawData + Offset;
437 uint8_t *End = Ptr + Dir->Size;
438 while (Ptr < End) {
439 debug_directory *Debug = reinterpret_cast<debug_directory *>(Ptr);
440 if (Debug->PointerToRawData) {
441 if (Expected<uint32_t> FilePosOrErr =
442 virtualAddressToFileAddress(Debug->AddressOfRawData))
443 Debug->PointerToRawData = *FilePosOrErr;
444 else
445 return FilePosOrErr.takeError();
446 }
447 Ptr += sizeof(debug_directory);
448 Offset += sizeof(debug_directory);
449 }
450 // Debug directory found and patched, all done.
451 return Error::success();
452 }
453 }
454 return createStringError(object_error::parse_failed,
455 "debug directory not found");
456}
457
459 bool IsBigObj = Obj.getSections().size() > MaxNumberOfSections16;
460 if (IsBigObj && Obj.IsPE)
461 return createStringError(object_error::parse_failed,
462 "too many sections for executable");
463 return write(IsBigObj);
464}
465
466} // end namespace coff
467} // end namespace objcopy
468} // end namespace llvm
for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))
arc branch finalize
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
bool End
Definition: ELF_riscv.cpp:480
Symbol * Sym
Definition: ELF_riscv.cpp:479
while(!ToSimplify.empty())
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:165
const T * data() const
Definition: ArrayRef.h:162
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
size_t getOffset(CachedHashStringRef S) const
Get the offest of a string in the string table.
void write(raw_ostream &OS) const
size_t add(CachedHashStringRef S)
Add a string to the builder.
void finalize()
Analyze the strings and build the final table.
static Twine utohexstr(const uint64_t &Val)
Definition: Twine.h:416
static std::unique_ptr< WritableMemoryBuffer > getNewMemBuffer(size_t Size, const Twine &BufferName="")
Allocate a new zero-initialized MemoryBuffer of the specified size.
raw_ostream & write(unsigned char C)
@ IMAGE_FILE_MACHINE_UNKNOWN
Definition: COFF.h:95
@ IMAGE_SCN_CNT_CODE
Definition: COFF.h:302
@ IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: COFF.h:303
@ IMAGE_SCN_LNK_NRELOC_OVFL
Definition: COFF.h:329
@ NameSize
Definition: COFF.h:57
@ DEBUG_DIRECTORY
Definition: COFF.h:603
@ IMAGE_SYM_CLASS_STATIC
Static.
Definition: COFF.h:224
bool encodeSectionName(char *Out, uint64_t Offset)
Encode section name based on string table offset.
Definition: COFF.cpp:39
const int32_t MaxNumberOfSections16
Definition: COFF.h:32
static const char BigObjMagic[]
Definition: COFF.h:37
static const char PEMagic[]
Definition: COFF.h:35
void copyPeHeader(PeHeader1Ty &Dest, const PeHeader2Ty &Src)
Definition: COFFObject.h:175
coff_symbol< support::ulittle16_t > coff_symbol16
Definition: COFF.h:265
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition: Error.h:1244
@ Ref
The access may reference the value stored in memory.
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
ArrayRef< Symbol > getSymbols() const
Definition: COFFObject.h:109
ArrayRef< uint8_t > DosStub
Definition: COFFObject.h:99
iterator_range< std::vector< Symbol >::iterator > getMutableSymbols()
Definition: COFFObject.h:112
object::coff_file_header CoffFileHeader
Definition: COFFObject.h:101
const Symbol * findSymbol(size_t UniqueId) const
Definition: COFFObject.cpp:33
std::vector< object::data_directory > DataDirectories
Definition: COFFObject.h:107
const Section * findSection(ssize_t UniqueId) const
Definition: COFFObject.cpp:85
object::pe32plus_header PeHeader
Definition: COFFObject.h:104
iterator_range< std::vector< Section >::iterator > getMutableSections()
Definition: COFFObject.h:128
object::dos_header DosHeader
Definition: COFFObject.h:98
ArrayRef< Section > getSections() const
Definition: COFFObject.h:125
support::ulittle16_t Machine
Definition: COFF.h:76
support::ulittle32_t NumberOfSymbols
Definition: COFF.h:80
support::ulittle32_t PointerToSymbolTable
Definition: COFF.h:79
support::ulittle16_t NumberOfSections
Definition: COFF.h:77
support::ulittle16_t SizeOfOptionalHeader
Definition: COFF.h:81
support::ulittle32_t TimeDateStamp
Definition: COFF.h:78
support::ulittle32_t AddressOfNewExeHeader
Definition: COFF.h:72
support::ulittle32_t SizeOfImage
Definition: COFF.h:159
support::ulittle32_t SizeOfHeaders
Definition: COFF.h:160
support::ulittle32_t CheckSum
Definition: COFF.h:161
support::ulittle32_t SizeOfInitializedData
Definition: COFF.h:145
support::ulittle32_t FileAlignment
Definition: COFF.h:151
support::ulittle32_t NumberOfRvaAndSize
Definition: COFF.h:169
support::ulittle32_t SectionAlignment
Definition: COFF.h:150