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/ADT/StringSwitch.h"
15 #include "llvm/ADT/Triple.h"
16 #include "llvm/Object/ObjectFile.h"
17 #include "llvm/Support/COFF.h"
18 #include "llvm/Support/Endian.h"
21 using namespace object;
24 using support::ulittle8_t;
25 using support::ulittle16_t;
26 using support::ulittle32_t;
27 using support::little16_t;
31 struct coff_file_header {
33 ulittle16_t NumberOfSections;
34 ulittle32_t TimeDateStamp;
35 ulittle32_t PointerToSymbolTable;
36 ulittle32_t NumberOfSymbols;
37 ulittle16_t SizeOfOptionalHeader;
38 ulittle16_t Characteristics;
42 extern char coff_file_header_layout_static_assert
43 [sizeof(coff_file_header) == 20 ? 1 : -1];
47 struct StringTableOffset {
54 StringTableOffset Offset;
58 little16_t SectionNumber;
62 ulittle8_t ComplexType;
65 ulittle8_t StorageClass;
66 ulittle8_t NumberOfAuxSymbols;
70 extern char coff_coff_symbol_layout_static_assert
71 [sizeof(coff_symbol) == 18 ? 1 : -1];
76 ulittle32_t VirtualSize;
77 ulittle32_t VirtualAddress;
78 ulittle32_t SizeOfRawData;
79 ulittle32_t PointerToRawData;
80 ulittle32_t PointerToRelocations;
81 ulittle32_t PointerToLinenumbers;
82 ulittle16_t NumberOfRelocations;
83 ulittle16_t NumberOfLinenumbers;
84 ulittle32_t Characteristics;
88 extern char coff_coff_section_layout_static_assert
89 [sizeof(coff_section) == 40 ? 1 : -1];
92 class COFFObjectFile : public ObjectFile {
95 const coff_file_header *Header;
96 const coff_section *SectionTable;
97 const coff_symbol *SymbolTable;
98 const char *StringTable;
100 const coff_section *getSection(std::size_t index) const;
101 const char *getString(std::size_t offset) const;
104 virtual SymbolRef getSymbolNext(DataRefImpl Symb) const;
105 virtual StringRef getSymbolName(DataRefImpl Symb) const;
106 virtual uint64_t getSymbolAddress(DataRefImpl Symb) const;
107 virtual uint64_t getSymbolSize(DataRefImpl Symb) const;
108 virtual char getSymbolNMTypeChar(DataRefImpl Symb) const;
109 virtual bool isSymbolInternal(DataRefImpl Symb) const;
111 virtual SectionRef getSectionNext(DataRefImpl Sec) const;
112 virtual StringRef getSectionName(DataRefImpl Sec) const;
113 virtual uint64_t getSectionAddress(DataRefImpl Sec) const;
114 virtual uint64_t getSectionSize(DataRefImpl Sec) const;
115 virtual StringRef getSectionContents(DataRefImpl Sec) const;
116 virtual bool isSectionText(DataRefImpl Sec) const;
119 COFFObjectFile(MemoryBuffer *Object);
120 virtual symbol_iterator begin_symbols() const;
121 virtual symbol_iterator end_symbols() const;
122 virtual section_iterator begin_sections() const;
123 virtual section_iterator end_sections() const;
125 virtual uint8_t getBytesInAddress() const;
126 virtual StringRef getFileFormatName() const;
127 virtual unsigned getArch() const;
131 SymbolRef COFFObjectFile::getSymbolNext(DataRefImpl Symb) const {
132 const coff_symbol *symb = reinterpret_cast<const coff_symbol*>(Symb.p);
133 symb += 1 + symb->NumberOfAuxSymbols;
134 Symb.p = reinterpret_cast<intptr_t>(symb);
135 return SymbolRef(Symb, this);
138 StringRef COFFObjectFile::getSymbolName(DataRefImpl Symb) const {
139 const coff_symbol *symb = reinterpret_cast<const coff_symbol*>(Symb.p);
140 // Check for string table entry. First 4 bytes are 0.
141 if (symb->Name.Offset.Zeroes == 0) {
142 uint32_t Offset = symb->Name.Offset.Offset;
143 return StringRef(getString(Offset));
146 if (symb->Name.ShortName[7] == 0)
147 // Null terminated, let ::strlen figure out the length.
148 return StringRef(symb->Name.ShortName);
149 // Not null terminated, use all 8 bytes.
150 return StringRef(symb->Name.ShortName, 8);
153 uint64_t COFFObjectFile::getSymbolAddress(DataRefImpl Symb) const {
154 const coff_symbol *symb = reinterpret_cast<const coff_symbol*>(Symb.p);
155 const coff_section *Section = getSection(symb->SectionNumber);
156 char Type = getSymbolNMTypeChar(Symb);
157 if (Type == 'U' || Type == 'w')
158 return UnknownAddressOrSize;
160 return Section->VirtualAddress + symb->Value;
164 uint64_t COFFObjectFile::getSymbolSize(DataRefImpl Symb) const {
165 // FIXME: Return the correct size. This requires looking at all the symbols
166 // in the same section as this symbol, and looking for either the next
167 // symbol, or the end of the section.
168 const coff_symbol *symb = reinterpret_cast<const coff_symbol*>(Symb.p);
169 const coff_section *Section = getSection(symb->SectionNumber);
170 char Type = getSymbolNMTypeChar(Symb);
171 if (Type == 'U' || Type == 'w')
172 return UnknownAddressOrSize;
174 return Section->SizeOfRawData - symb->Value;
178 char COFFObjectFile::getSymbolNMTypeChar(DataRefImpl Symb) const {
179 const coff_symbol *symb = reinterpret_cast<const coff_symbol*>(Symb.p);
180 char ret = StringSwitch<char>(getSymbolName(Symb))
181 .StartsWith(".debug", 'N')
182 .StartsWith(".sxdata", 'N')
188 uint32_t Characteristics = 0;
189 uint32_t PointerToRawData = 0;
190 const coff_section *Section = getSection(symb->SectionNumber);
192 Characteristics = Section->Characteristics;
193 PointerToRawData = Section->PointerToRawData;
196 switch (symb->SectionNumber) {
197 case COFF::IMAGE_SYM_UNDEFINED:
198 // Check storage classes.
199 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL)
200 return 'w'; // Don't do ::toupper.
204 case COFF::IMAGE_SYM_ABSOLUTE:
207 case COFF::IMAGE_SYM_DEBUG:
211 // Check section type.
212 if (Characteristics & COFF::IMAGE_SCN_CNT_CODE)
214 else if ( Characteristics & COFF::IMAGE_SCN_MEM_READ
215 && ~Characteristics & COFF::IMAGE_SCN_MEM_WRITE) // Read only.
217 else if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
219 else if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
221 else if (Characteristics & COFF::IMAGE_SCN_LNK_INFO)
224 // Check for section symbol.
225 else if ( symb->StorageClass == COFF::IMAGE_SYM_CLASS_STATIC
230 if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL)
231 ret = ::toupper(ret);
236 bool COFFObjectFile::isSymbolInternal(DataRefImpl Symb) const {
240 SectionRef COFFObjectFile::getSectionNext(DataRefImpl Sec) const {
241 const coff_section *sec = reinterpret_cast<const coff_section*>(Sec.p);
243 Sec.p = reinterpret_cast<intptr_t>(sec);
244 return SectionRef(Sec, this);
247 StringRef COFFObjectFile::getSectionName(DataRefImpl Sec) const {
248 const coff_section *sec = reinterpret_cast<const coff_section*>(Sec.p);
250 if (sec->Name[7] == 0)
251 // Null terminated, let ::strlen figure out the length.
254 // Not null terminated, use all 8 bytes.
255 name = StringRef(sec->Name, 8);
257 // Check for string table entry. First byte is '/'.
258 if (name[0] == '/') {
260 name.substr(1).getAsInteger(10, Offset);
261 return StringRef(getString(Offset));
264 // It's just a normal name.
268 uint64_t COFFObjectFile::getSectionAddress(DataRefImpl Sec) const {
269 const coff_section *sec = reinterpret_cast<const coff_section*>(Sec.p);
270 return sec->VirtualAddress;
273 uint64_t COFFObjectFile::getSectionSize(DataRefImpl Sec) const {
274 const coff_section *sec = reinterpret_cast<const coff_section*>(Sec.p);
275 return sec->SizeOfRawData;
278 StringRef COFFObjectFile::getSectionContents(DataRefImpl Sec) const {
279 const coff_section *sec = reinterpret_cast<const coff_section*>(Sec.p);
280 return StringRef(reinterpret_cast<const char *>(base + sec->PointerToRawData),
284 bool COFFObjectFile::isSectionText(DataRefImpl Sec) const {
285 const coff_section *sec = reinterpret_cast<const coff_section*>(Sec.p);
286 return sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE;
289 COFFObjectFile::COFFObjectFile(MemoryBuffer *Object)
290 : ObjectFile(Object) {
294 if (base[0] == 0x4d && base[1] == 0x5a) {
295 // PE/COFF, seek through MS-DOS compatibility stub and 4-byte
296 // PE signature to find 'normal' COFF header.
297 HeaderOff += *reinterpret_cast<const ulittle32_t *>(base + 0x3c);
301 Header = reinterpret_cast<const coff_file_header *>(base + HeaderOff);
303 reinterpret_cast<const coff_section *>( base
305 + sizeof(coff_file_header)
306 + Header->SizeOfOptionalHeader);
308 reinterpret_cast<const coff_symbol *>(base + Header->PointerToSymbolTable);
310 // Find string table.
311 StringTable = reinterpret_cast<const char *>(base)
312 + Header->PointerToSymbolTable
313 + Header->NumberOfSymbols * 18;
316 ObjectFile::symbol_iterator COFFObjectFile::begin_symbols() const {
318 memset(&ret, 0, sizeof(DataRefImpl));
319 ret.p = reinterpret_cast<intptr_t>(SymbolTable);
320 return symbol_iterator(SymbolRef(ret, this));
323 ObjectFile::symbol_iterator COFFObjectFile::end_symbols() const {
324 // The symbol table ends where the string table begins.
326 memset(&ret, 0, sizeof(DataRefImpl));
327 ret.p = reinterpret_cast<intptr_t>(StringTable);
328 return symbol_iterator(SymbolRef(ret, this));
331 ObjectFile::section_iterator COFFObjectFile::begin_sections() const {
333 memset(&ret, 0, sizeof(DataRefImpl));
334 ret.p = reinterpret_cast<intptr_t>(SectionTable);
335 return section_iterator(SectionRef(ret, this));
338 ObjectFile::section_iterator COFFObjectFile::end_sections() const {
340 memset(&ret, 0, sizeof(DataRefImpl));
341 ret.p = reinterpret_cast<intptr_t>(SectionTable + Header->NumberOfSections);
342 return section_iterator(SectionRef(ret, this));
345 uint8_t COFFObjectFile::getBytesInAddress() const {
346 return getArch() == Triple::x86_64 ? 8 : 4;
349 StringRef COFFObjectFile::getFileFormatName() const {
350 switch(Header->Machine) {
351 case COFF::IMAGE_FILE_MACHINE_I386:
353 case COFF::IMAGE_FILE_MACHINE_AMD64:
354 return "COFF-x86-64";
356 return "COFF-<unknown arch>";
360 unsigned COFFObjectFile::getArch() const {
361 switch(Header->Machine) {
362 case COFF::IMAGE_FILE_MACHINE_I386:
364 case COFF::IMAGE_FILE_MACHINE_AMD64:
365 return Triple::x86_64;
367 return Triple::UnknownArch;
371 const coff_section *COFFObjectFile::getSection(std::size_t index) const {
372 if (index > 0 && index <= Header->NumberOfSections)
373 return SectionTable + (index - 1);
377 const char *COFFObjectFile::getString(std::size_t offset) const {
378 const ulittle32_t *StringTableSize =
379 reinterpret_cast<const ulittle32_t *>(StringTable);
380 if (offset < *StringTableSize)
381 return StringTable + offset;
387 ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) {
388 return new COFFObjectFile(Object);
391 } // end namespace llvm