1 //===- COFFObjectFile.cpp - COFF object file implementation -----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file declares the COFFObjectFile class.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Object/COFF.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/ADT/Triple.h"
19 using namespace object;
22 using support::ulittle8_t;
23 using support::ulittle16_t;
24 using support::ulittle32_t;
25 using support::little16_t;
29 // Returns false if size is greater than the buffer size. And sets ec.
30 bool checkSize(const MemoryBuffer *m, error_code &ec, uint64_t size) {
31 if (m->getBufferSize() < size) {
32 ec = object_error::unexpected_eof;
38 // Returns false if any bytes in [addr, addr + size) fall outsize of m.
39 bool checkAddr(const MemoryBuffer *m,
43 if (addr + size < addr ||
45 addr + size > uintptr_t(m->getBufferEnd())) {
46 ec = object_error::unexpected_eof;
53 const coff_symbol *COFFObjectFile::toSymb(DataRefImpl Symb) const {
54 const coff_symbol *addr = reinterpret_cast<const coff_symbol*>(Symb.p);
57 // Verify that the symbol points to a valid entry in the symbol table.
58 uintptr_t offset = uintptr_t(addr) - uintptr_t(base());
59 if (offset < Header->PointerToSymbolTable
60 || offset >= Header->PointerToSymbolTable
61 + (Header->NumberOfSymbols * sizeof(coff_symbol)))
62 report_fatal_error("Symbol was outside of symbol table.");
64 assert((offset - Header->PointerToSymbolTable) % sizeof(coff_symbol)
65 == 0 && "Symbol did not point to the beginning of a symbol");
71 const coff_section *COFFObjectFile::toSec(DataRefImpl Sec) const {
72 const coff_section *addr = reinterpret_cast<const coff_section*>(Sec.p);
75 // Verify that the section points to a valid entry in the section table.
76 if (addr < SectionTable
77 || addr >= (SectionTable + Header->NumberOfSections))
78 report_fatal_error("Section was outside of section table.");
80 uintptr_t offset = uintptr_t(addr) - uintptr_t(SectionTable);
81 assert(offset % sizeof(coff_section) == 0 &&
82 "Section did not point to the beginning of a section");
88 error_code COFFObjectFile::getSymbolNext(DataRefImpl Symb,
89 SymbolRef &Result) const {
90 const coff_symbol *symb = toSymb(Symb);
91 symb += 1 + symb->NumberOfAuxSymbols;
92 Symb.p = reinterpret_cast<uintptr_t>(symb);
93 Result = SymbolRef(Symb, this);
94 return object_error::success;
97 error_code COFFObjectFile::getSymbolName(DataRefImpl Symb,
98 StringRef &Result) const {
99 const coff_symbol *symb = toSymb(Symb);
100 // Check for string table entry. First 4 bytes are 0.
101 if (symb->Name.Offset.Zeroes == 0) {
102 uint32_t Offset = symb->Name.Offset.Offset;
103 if (error_code ec = getString(Offset, Result))
105 return object_error::success;
108 if (symb->Name.ShortName[7] == 0)
109 // Null terminated, let ::strlen figure out the length.
110 Result = StringRef(symb->Name.ShortName);
112 // Not null terminated, use all 8 bytes.
113 Result = StringRef(symb->Name.ShortName, 8);
114 return object_error::success;
117 error_code COFFObjectFile::getSymbolOffset(DataRefImpl Symb,
118 uint64_t &Result) const {
119 const coff_symbol *symb = toSymb(Symb);
120 const coff_section *Section = NULL;
121 if (error_code ec = getSection(symb->SectionNumber, Section))
124 if (error_code ec = getSymbolNMTypeChar(Symb, Type))
126 if (Type == 'U' || Type == 'w')
127 Result = UnknownAddressOrSize;
129 Result = Section->VirtualAddress + symb->Value;
131 Result = symb->Value;
132 return object_error::success;
135 error_code COFFObjectFile::getSymbolAddress(DataRefImpl Symb,
136 uint64_t &Result) const {
137 const coff_symbol *symb = toSymb(Symb);
138 const coff_section *Section = NULL;
139 if (error_code ec = getSection(symb->SectionNumber, Section))
142 if (error_code ec = getSymbolNMTypeChar(Symb, Type))
144 if (Type == 'U' || Type == 'w')
145 Result = UnknownAddressOrSize;
147 Result = reinterpret_cast<uintptr_t>(base() +
148 Section->PointerToRawData +
151 Result = reinterpret_cast<uintptr_t>(base() + symb->Value);
152 return object_error::success;
155 error_code COFFObjectFile::getSymbolType(DataRefImpl Symb,
156 SymbolRef::SymbolType &Result) const {
157 const coff_symbol *symb = toSymb(Symb);
158 Result = SymbolRef::ST_Other;
159 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL &&
160 symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) {
161 Result = SymbolRef::ST_External;
163 if (symb->Type.ComplexType == COFF::IMAGE_SYM_DTYPE_FUNCTION) {
164 Result = SymbolRef::ST_Function;
167 if (error_code ec = getSymbolNMTypeChar(Symb, Type))
169 if (Type == 'r' || Type == 'R') {
170 Result = SymbolRef::ST_Data;
174 return object_error::success;
177 error_code COFFObjectFile::isSymbolGlobal(DataRefImpl Symb,
178 bool &Result) const {
179 const coff_symbol *symb = toSymb(Symb);
180 Result = (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL);
181 return object_error::success;
184 error_code COFFObjectFile::getSymbolSize(DataRefImpl Symb,
185 uint64_t &Result) const {
186 // FIXME: Return the correct size. This requires looking at all the symbols
187 // in the same section as this symbol, and looking for either the next
188 // symbol, or the end of the section.
189 const coff_symbol *symb = toSymb(Symb);
190 const coff_section *Section = NULL;
191 if (error_code ec = getSection(symb->SectionNumber, Section))
194 if (error_code ec = getSymbolNMTypeChar(Symb, Type))
196 if (Type == 'U' || Type == 'w')
197 Result = UnknownAddressOrSize;
199 Result = Section->SizeOfRawData - symb->Value;
202 return object_error::success;
205 error_code COFFObjectFile::getSymbolNMTypeChar(DataRefImpl Symb,
206 char &Result) const {
207 const coff_symbol *symb = toSymb(Symb);
209 if (error_code ec = getSymbolName(Symb, name))
211 char ret = StringSwitch<char>(name)
212 .StartsWith(".debug", 'N')
213 .StartsWith(".sxdata", 'N')
218 return object_error::success;
221 uint32_t Characteristics = 0;
222 if (symb->SectionNumber > 0) {
223 const coff_section *Section = NULL;
224 if (error_code ec = getSection(symb->SectionNumber, Section))
226 Characteristics = Section->Characteristics;
229 switch (symb->SectionNumber) {
230 case COFF::IMAGE_SYM_UNDEFINED:
231 // Check storage classes.
232 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL) {
234 return object_error::success; // Don't do ::toupper.
238 case COFF::IMAGE_SYM_ABSOLUTE:
241 case COFF::IMAGE_SYM_DEBUG:
245 // Check section type.
246 if (Characteristics & COFF::IMAGE_SCN_CNT_CODE)
248 else if ( Characteristics & COFF::IMAGE_SCN_MEM_READ
249 && ~Characteristics & COFF::IMAGE_SCN_MEM_WRITE) // Read only.
251 else if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
253 else if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
255 else if (Characteristics & COFF::IMAGE_SCN_LNK_INFO)
258 // Check for section symbol.
259 else if ( symb->StorageClass == COFF::IMAGE_SYM_CLASS_STATIC
264 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL)
265 ret = ::toupper(ret);
268 return object_error::success;
271 error_code COFFObjectFile::isSymbolInternal(DataRefImpl Symb,
272 bool &Result) const {
274 return object_error::success;
277 error_code COFFObjectFile::getSectionNext(DataRefImpl Sec,
278 SectionRef &Result) const {
279 const coff_section *sec = toSec(Sec);
281 Sec.p = reinterpret_cast<uintptr_t>(sec);
282 Result = SectionRef(Sec, this);
283 return object_error::success;
286 error_code COFFObjectFile::getSectionName(DataRefImpl Sec,
287 StringRef &Result) const {
288 const coff_section *sec = toSec(Sec);
290 if (sec->Name[7] == 0)
291 // Null terminated, let ::strlen figure out the length.
294 // Not null terminated, use all 8 bytes.
295 name = StringRef(sec->Name, 8);
297 // Check for string table entry. First byte is '/'.
298 if (name[0] == '/') {
300 name.substr(1).getAsInteger(10, Offset);
301 if (error_code ec = getString(Offset, name))
306 return object_error::success;
309 error_code COFFObjectFile::getSectionAddress(DataRefImpl Sec,
310 uint64_t &Result) const {
311 const coff_section *sec = toSec(Sec);
312 Result = sec->VirtualAddress;
313 return object_error::success;
316 error_code COFFObjectFile::getSectionSize(DataRefImpl Sec,
317 uint64_t &Result) const {
318 const coff_section *sec = toSec(Sec);
319 Result = sec->SizeOfRawData;
320 return object_error::success;
323 error_code COFFObjectFile::getSectionContents(DataRefImpl Sec,
324 StringRef &Result) const {
325 const coff_section *sec = toSec(Sec);
326 // The only thing that we need to verify is that the contents is contained
327 // within the file bounds. We don't need to make sure it doesn't cover other
328 // data, as there's nothing that says that is not allowed.
329 uintptr_t con_start = uintptr_t(base()) + sec->PointerToRawData;
330 uintptr_t con_end = con_start + sec->SizeOfRawData;
331 if (con_end >= uintptr_t(Data->getBufferEnd()))
332 return object_error::parse_failed;
333 Result = StringRef(reinterpret_cast<const char*>(con_start),
335 return object_error::success;
338 error_code COFFObjectFile::isSectionText(DataRefImpl Sec,
339 bool &Result) const {
340 const coff_section *sec = toSec(Sec);
341 Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE;
342 return object_error::success;
345 error_code COFFObjectFile::isSectionData(DataRefImpl Sec,
346 bool &Result) const {
347 const coff_section *sec = toSec(Sec);
348 Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
349 return object_error::success;
352 error_code COFFObjectFile::isSectionBSS(DataRefImpl Sec,
353 bool &Result) const {
354 const coff_section *sec = toSec(Sec);
355 Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
356 return object_error::success;
359 error_code COFFObjectFile::sectionContainsSymbol(DataRefImpl Sec,
361 bool &Result) const {
362 // FIXME: Unimplemented.
364 return object_error::success;
367 COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec)
368 : ObjectFile(Binary::isCOFF, Object, ec) {
369 // Check that we at least have enough room for a header.
370 if (!checkSize(Data, ec, sizeof(coff_file_header))) return;
372 // The actual starting location of the COFF header in the file. This can be
373 // non-zero in PE/COFF files.
374 uint64_t HeaderStart = 0;
376 // Check if this is a PE/COFF file.
377 if (base()[0] == 0x4d && base()[1] == 0x5a) {
378 // PE/COFF, seek through MS-DOS compatibility stub and 4-byte
379 // PE signature to find 'normal' COFF header.
380 if (!checkSize(Data, ec, 0x3c + 8)) return;
381 HeaderStart += *reinterpret_cast<const ulittle32_t *>(base() + 0x3c);
382 // Check the PE header. ("PE\0\0")
383 if (std::memcmp(base() + HeaderStart, "PE\0\0", 4) != 0) {
384 ec = object_error::parse_failed;
387 HeaderStart += 4; // Skip the PE Header.
390 Header = reinterpret_cast<const coff_file_header *>(base() + HeaderStart);
391 if (!checkAddr(Data, ec, uintptr_t(Header), sizeof(coff_file_header)))
395 reinterpret_cast<const coff_section *>( base()
397 + sizeof(coff_file_header)
398 + Header->SizeOfOptionalHeader);
399 if (!checkAddr(Data, ec, uintptr_t(SectionTable),
400 Header->NumberOfSections * sizeof(coff_section)))
404 reinterpret_cast<const coff_symbol *>(base()
405 + Header->PointerToSymbolTable);
406 if (!checkAddr(Data, ec, uintptr_t(SymbolTable),
407 Header->NumberOfSymbols * sizeof(coff_symbol)))
410 // Find string table.
411 StringTable = reinterpret_cast<const char *>(base())
412 + Header->PointerToSymbolTable
413 + Header->NumberOfSymbols * sizeof(coff_symbol);
414 if (!checkAddr(Data, ec, uintptr_t(StringTable), sizeof(ulittle32_t)))
417 StringTableSize = *reinterpret_cast<const ulittle32_t *>(StringTable);
418 if (!checkAddr(Data, ec, uintptr_t(StringTable), StringTableSize))
420 // Check that the string table is null terminated if has any in it.
421 if (StringTableSize < 4
422 || (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)) {
423 ec = object_error::parse_failed;
427 ec = object_error::success;
430 ObjectFile::symbol_iterator COFFObjectFile::begin_symbols() const {
432 std::memset(&ret, 0, sizeof(DataRefImpl));
433 ret.p = reinterpret_cast<intptr_t>(SymbolTable);
434 return symbol_iterator(SymbolRef(ret, this));
437 ObjectFile::symbol_iterator COFFObjectFile::end_symbols() const {
438 // The symbol table ends where the string table begins.
440 std::memset(&ret, 0, sizeof(DataRefImpl));
441 ret.p = reinterpret_cast<intptr_t>(StringTable);
442 return symbol_iterator(SymbolRef(ret, this));
445 ObjectFile::section_iterator COFFObjectFile::begin_sections() const {
447 std::memset(&ret, 0, sizeof(DataRefImpl));
448 ret.p = reinterpret_cast<intptr_t>(SectionTable);
449 return section_iterator(SectionRef(ret, this));
452 ObjectFile::section_iterator COFFObjectFile::end_sections() const {
454 std::memset(&ret, 0, sizeof(DataRefImpl));
455 ret.p = reinterpret_cast<intptr_t>(SectionTable + Header->NumberOfSections);
456 return section_iterator(SectionRef(ret, this));
459 uint8_t COFFObjectFile::getBytesInAddress() const {
460 return getArch() == Triple::x86_64 ? 8 : 4;
463 StringRef COFFObjectFile::getFileFormatName() const {
464 switch(Header->Machine) {
465 case COFF::IMAGE_FILE_MACHINE_I386:
467 case COFF::IMAGE_FILE_MACHINE_AMD64:
468 return "COFF-x86-64";
470 return "COFF-<unknown arch>";
474 unsigned COFFObjectFile::getArch() const {
475 switch(Header->Machine) {
476 case COFF::IMAGE_FILE_MACHINE_I386:
478 case COFF::IMAGE_FILE_MACHINE_AMD64:
479 return Triple::x86_64;
481 return Triple::UnknownArch;
485 error_code COFFObjectFile::getSection(int32_t index,
486 const coff_section *&Result) const {
487 // Check for special index values.
488 if (index == COFF::IMAGE_SYM_UNDEFINED ||
489 index == COFF::IMAGE_SYM_ABSOLUTE ||
490 index == COFF::IMAGE_SYM_DEBUG)
492 else if (index > 0 && index <= Header->NumberOfSections)
493 // We already verified the section table data, so no need to check again.
494 Result = SectionTable + (index - 1);
496 return object_error::parse_failed;
497 return object_error::success;
500 error_code COFFObjectFile::getString(uint32_t offset,
501 StringRef &Result) const {
502 if (StringTableSize <= 4)
503 // Tried to get a string from an empty string table.
504 return object_error::parse_failed;
505 if (offset >= StringTableSize)
506 return object_error::unexpected_eof;
507 Result = StringRef(StringTable + offset);
508 return object_error::success;
511 const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const {
512 assert(Rel.d.b < Header->NumberOfSections && "Section index out of range!");
513 const coff_section *Sect = NULL;
514 getSection(Rel.d.b, Sect);
515 assert(Rel.d.a < Sect->NumberOfRelocations && "Relocation index out of range!");
517 reinterpret_cast<const coff_relocation*>(base() +
518 Sect->PointerToRelocations) +
521 error_code COFFObjectFile::getRelocationNext(DataRefImpl Rel,
522 RelocationRef &Res) const {
523 const coff_section *Sect = NULL;
524 if (error_code ec = getSection(Rel.d.b, Sect))
526 if (++Rel.d.a >= Sect->NumberOfRelocations) {
528 while (++Rel.d.b < Header->NumberOfSections) {
529 const coff_section *Sect = NULL;
530 getSection(Rel.d.b, Sect);
531 if (Sect->NumberOfRelocations > 0)
535 Res = RelocationRef(Rel, this);
536 return object_error::success;
538 error_code COFFObjectFile::getRelocationAddress(DataRefImpl Rel,
539 uint64_t &Res) const {
540 const coff_section *Sect = NULL;
541 if (error_code ec = getSection(Rel.d.b, Sect))
543 const coff_relocation* R = toRel(Rel);
544 Res = reinterpret_cast<uintptr_t>(base() +
545 Sect->PointerToRawData +
547 return object_error::success;
549 error_code COFFObjectFile::getRelocationSymbol(DataRefImpl Rel,
550 SymbolRef &Res) const {
551 const coff_relocation* R = toRel(Rel);
553 Symb.p = reinterpret_cast<uintptr_t>(SymbolTable + R->SymbolTableIndex);
554 Res = SymbolRef(Symb, this);
555 return object_error::success;
557 error_code COFFObjectFile::getRelocationType(DataRefImpl Rel,
558 uint32_t &Res) const {
559 const coff_relocation* R = toRel(Rel);
561 return object_error::success;
563 error_code COFFObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel,
564 int64_t &Res) const {
566 return object_error::success;
568 ObjectFile::relocation_iterator COFFObjectFile::begin_relocations() const {
572 return relocation_iterator(RelocationRef(ret, this));
574 ObjectFile::relocation_iterator COFFObjectFile::end_relocations() const {
577 ret.d.b = Header->NumberOfSections;
578 return relocation_iterator(RelocationRef(ret, this));
584 ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) {
586 return new COFFObjectFile(Object, ec);
589 } // end namespace llvm