xref: /llvm-project/llvm/lib/Object/COFFObjectFile.cpp (revision 7e4b976c365b592d03caaa2fc51a534736996531) 
1 //===- COFFObjectFile.cpp - COFF object file implementation -----*- C++ -*-===//
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 // This file declares the COFFObjectFile class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/Object/COFF.h"
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/ADT/StringSwitch.h"
17 #include "llvm/ADT/Triple.h"
18 
19 using namespace llvm;
20 using namespace object;
21 
22 namespace {
23 using support::ulittle8_t;
24 using support::ulittle16_t;
25 using support::ulittle32_t;
26 using support::little16_t;
27 }
28 
29 namespace {
30 // Returns false if size is greater than the buffer size. And sets ec.
31 bool checkSize(const MemoryBuffer *m, error_code &ec, uint64_t size) {
32   if (m->getBufferSize() < size) {
33     ec = object_error::unexpected_eof;
34     return false;
35   }
36   return true;
37 }
38 
39 // Returns false if any bytes in [addr, addr + size) fall outsize of m.
40 bool checkAddr(const MemoryBuffer *m,
41                error_code &ec,
42                uintptr_t addr,
43                uint64_t size) {
44   if (addr + size < addr ||
45       addr + size < size ||
46       addr + size > uintptr_t(m->getBufferEnd())) {
47     ec = object_error::unexpected_eof;
48     return false;
49   }
50   return true;
51 }
52 }
53 
54 const coff_symbol *COFFObjectFile::toSymb(DataRefImpl Symb) const {
55   const coff_symbol *addr = reinterpret_cast<const coff_symbol*>(Symb.p);
56 
57 # ifndef NDEBUG
58   // Verify that the symbol points to a valid entry in the symbol table.
59   uintptr_t offset = uintptr_t(addr) - uintptr_t(base());
60   if (offset < Header->PointerToSymbolTable
61       || offset >= Header->PointerToSymbolTable
62          + (Header->NumberOfSymbols * sizeof(coff_symbol)))
63     report_fatal_error("Symbol was outside of symbol table.");
64 
65   assert((offset - Header->PointerToSymbolTable) % sizeof(coff_symbol)
66          == 0 && "Symbol did not point to the beginning of a symbol");
67 # endif
68 
69   return addr;
70 }
71 
72 const coff_section *COFFObjectFile::toSec(DataRefImpl Sec) const {
73   const coff_section *addr = reinterpret_cast<const coff_section*>(Sec.p);
74 
75 # ifndef NDEBUG
76   // Verify that the section points to a valid entry in the section table.
77   if (addr < SectionTable
78       || addr >= (SectionTable + Header->NumberOfSections))
79     report_fatal_error("Section was outside of section table.");
80 
81   uintptr_t offset = uintptr_t(addr) - uintptr_t(SectionTable);
82   assert(offset % sizeof(coff_section) == 0 &&
83          "Section did not point to the beginning of a section");
84 # endif
85 
86   return addr;
87 }
88 
89 error_code COFFObjectFile::getSymbolNext(DataRefImpl Symb,
90                                          SymbolRef &Result) const {
91   const coff_symbol *symb = toSymb(Symb);
92   symb += 1 + symb->NumberOfAuxSymbols;
93   Symb.p = reinterpret_cast<uintptr_t>(symb);
94   Result = SymbolRef(Symb, this);
95   return object_error::success;
96 }
97 
98  error_code COFFObjectFile::getSymbolName(DataRefImpl Symb,
99                                           StringRef &Result) const {
100   const coff_symbol *symb = toSymb(Symb);
101   return getSymbolName(symb, Result);
102 }
103 
104 error_code COFFObjectFile::getSymbolFileOffset(DataRefImpl Symb,
105                                             uint64_t &Result) const {
106   const coff_symbol *symb = toSymb(Symb);
107   const coff_section *Section = NULL;
108   if (error_code ec = getSection(symb->SectionNumber, Section))
109     return ec;
110   char Type;
111   if (error_code ec = getSymbolNMTypeChar(Symb, Type))
112     return ec;
113   if (Type == 'U' || Type == 'w')
114     Result = UnknownAddressOrSize;
115   else if (Section)
116     Result = Section->PointerToRawData + symb->Value;
117   else
118     Result = symb->Value;
119   return object_error::success;
120 }
121 
122 error_code COFFObjectFile::getSymbolAddress(DataRefImpl Symb,
123                                             uint64_t &Result) const {
124   const coff_symbol *symb = toSymb(Symb);
125   const coff_section *Section = NULL;
126   if (error_code ec = getSection(symb->SectionNumber, Section))
127     return ec;
128   char Type;
129   if (error_code ec = getSymbolNMTypeChar(Symb, Type))
130     return ec;
131   if (Type == 'U' || Type == 'w')
132     Result = UnknownAddressOrSize;
133   else if (Section)
134     Result = Section->VirtualAddress + symb->Value;
135   else
136     Result = symb->Value;
137   return object_error::success;
138 }
139 
140 error_code COFFObjectFile::getSymbolType(DataRefImpl Symb,
141                                          SymbolRef::Type &Result) const {
142   const coff_symbol *symb = toSymb(Symb);
143   Result = SymbolRef::ST_Other;
144   if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL &&
145       symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED) {
146     Result = SymbolRef::ST_Unknown;
147   } else {
148     if (symb->getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION) {
149       Result = SymbolRef::ST_Function;
150     } else {
151       char Type;
152       if (error_code ec = getSymbolNMTypeChar(Symb, Type))
153         return ec;
154       if (Type == 'r' || Type == 'R') {
155         Result = SymbolRef::ST_Data;
156       }
157     }
158   }
159   return object_error::success;
160 }
161 
162 error_code COFFObjectFile::getSymbolFlags(DataRefImpl Symb,
163                                           uint32_t &Result) const {
164   const coff_symbol *symb = toSymb(Symb);
165   Result = SymbolRef::SF_None;
166 
167   // TODO: Correctly set SF_FormatSpecific, SF_ThreadLocal, SF_Common
168 
169   if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL &&
170       symb->SectionNumber == COFF::IMAGE_SYM_UNDEFINED)
171     Result |= SymbolRef::SF_Undefined;
172 
173   // TODO: This are certainly too restrictive.
174   if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL)
175     Result |= SymbolRef::SF_Global;
176 
177   if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL)
178     Result |= SymbolRef::SF_Weak;
179 
180   if (symb->SectionNumber == COFF::IMAGE_SYM_ABSOLUTE)
181     Result |= SymbolRef::SF_Absolute;
182 
183   return object_error::success;
184 }
185 
186 error_code COFFObjectFile::getSymbolSize(DataRefImpl Symb,
187                                          uint64_t &Result) const {
188   // FIXME: Return the correct size. This requires looking at all the symbols
189   //        in the same section as this symbol, and looking for either the next
190   //        symbol, or the end of the section.
191   const coff_symbol *symb = toSymb(Symb);
192   const coff_section *Section = NULL;
193   if (error_code ec = getSection(symb->SectionNumber, Section))
194     return ec;
195   char Type;
196   if (error_code ec = getSymbolNMTypeChar(Symb, Type))
197     return ec;
198   if (Type == 'U' || Type == 'w')
199     Result = UnknownAddressOrSize;
200   else if (Section)
201     Result = Section->SizeOfRawData - symb->Value;
202   else
203     Result = 0;
204   return object_error::success;
205 }
206 
207 error_code COFFObjectFile::getSymbolNMTypeChar(DataRefImpl Symb,
208                                                char &Result) const {
209   const coff_symbol *symb = toSymb(Symb);
210   StringRef name;
211   if (error_code ec = getSymbolName(Symb, name))
212     return ec;
213   char ret = StringSwitch<char>(name)
214     .StartsWith(".debug", 'N')
215     .StartsWith(".sxdata", 'N')
216     .Default('?');
217 
218   if (ret != '?') {
219     Result = ret;
220     return object_error::success;
221   }
222 
223   uint32_t Characteristics = 0;
224   if (symb->SectionNumber > 0) {
225     const coff_section *Section = NULL;
226     if (error_code ec = getSection(symb->SectionNumber, Section))
227       return ec;
228     Characteristics = Section->Characteristics;
229   }
230 
231   switch (symb->SectionNumber) {
232   case COFF::IMAGE_SYM_UNDEFINED:
233     // Check storage classes.
234     if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL) {
235       Result = 'w';
236       return object_error::success; // Don't do ::toupper.
237     } else if (symb->Value != 0) // Check for common symbols.
238       ret = 'c';
239     else
240       ret = 'u';
241     break;
242   case COFF::IMAGE_SYM_ABSOLUTE:
243     ret = 'a';
244     break;
245   case COFF::IMAGE_SYM_DEBUG:
246     ret = 'n';
247     break;
248   default:
249     // Check section type.
250     if (Characteristics & COFF::IMAGE_SCN_CNT_CODE)
251       ret = 't';
252     else if (  Characteristics & COFF::IMAGE_SCN_MEM_READ
253             && ~Characteristics & COFF::IMAGE_SCN_MEM_WRITE) // Read only.
254       ret = 'r';
255     else if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
256       ret = 'd';
257     else if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
258       ret = 'b';
259     else if (Characteristics & COFF::IMAGE_SCN_LNK_INFO)
260       ret = 'i';
261 
262     // Check for section symbol.
263     else if (  symb->StorageClass == COFF::IMAGE_SYM_CLASS_STATIC
264             && symb->Value == 0)
265        ret = 's';
266   }
267 
268   if (symb->StorageClass == COFF::IMAGE_SYM_CLASS_EXTERNAL)
269     ret = ::toupper(ret);
270 
271   Result = ret;
272   return object_error::success;
273 }
274 
275 error_code COFFObjectFile::getSymbolSection(DataRefImpl Symb,
276                                             section_iterator &Result) const {
277   const coff_symbol *symb = toSymb(Symb);
278   if (symb->SectionNumber <= COFF::IMAGE_SYM_UNDEFINED)
279     Result = end_sections();
280   else {
281     const coff_section *sec = 0;
282     if (error_code ec = getSection(symb->SectionNumber, sec)) return ec;
283     DataRefImpl Sec;
284     std::memset(&Sec, 0, sizeof(Sec));
285     Sec.p = reinterpret_cast<uintptr_t>(sec);
286     Result = section_iterator(SectionRef(Sec, this));
287   }
288   return object_error::success;
289 }
290 
291 error_code COFFObjectFile::getSectionNext(DataRefImpl Sec,
292                                           SectionRef &Result) const {
293   const coff_section *sec = toSec(Sec);
294   sec += 1;
295   Sec.p = reinterpret_cast<uintptr_t>(sec);
296   Result = SectionRef(Sec, this);
297   return object_error::success;
298 }
299 
300 error_code COFFObjectFile::getSectionName(DataRefImpl Sec,
301                                           StringRef &Result) const {
302   const coff_section *sec = toSec(Sec);
303   StringRef name;
304   if (sec->Name[7] == 0)
305     // Null terminated, let ::strlen figure out the length.
306     name = sec->Name;
307   else
308     // Not null terminated, use all 8 bytes.
309     name = StringRef(sec->Name, 8);
310 
311   // Check for string table entry. First byte is '/'.
312   if (name[0] == '/') {
313     uint32_t Offset;
314     name.substr(1).getAsInteger(10, Offset);
315     if (error_code ec = getString(Offset, name))
316       return ec;
317   }
318 
319   Result = name;
320   return object_error::success;
321 }
322 
323 error_code COFFObjectFile::getSectionAddress(DataRefImpl Sec,
324                                              uint64_t &Result) const {
325   const coff_section *sec = toSec(Sec);
326   Result = sec->VirtualAddress;
327   return object_error::success;
328 }
329 
330 error_code COFFObjectFile::getSectionSize(DataRefImpl Sec,
331                                           uint64_t &Result) const {
332   const coff_section *sec = toSec(Sec);
333   Result = sec->SizeOfRawData;
334   return object_error::success;
335 }
336 
337 error_code COFFObjectFile::getSectionContents(DataRefImpl Sec,
338                                               StringRef &Result) const {
339   const coff_section *sec = toSec(Sec);
340   // The only thing that we need to verify is that the contents is contained
341   // within the file bounds. We don't need to make sure it doesn't cover other
342   // data, as there's nothing that says that is not allowed.
343   uintptr_t con_start = uintptr_t(base()) + sec->PointerToRawData;
344   uintptr_t con_end = con_start + sec->SizeOfRawData;
345   if (con_end > uintptr_t(Data->getBufferEnd()))
346     return object_error::parse_failed;
347   Result = StringRef(reinterpret_cast<const char*>(con_start),
348                      sec->SizeOfRawData);
349   return object_error::success;
350 }
351 
352 error_code COFFObjectFile::getSectionAlignment(DataRefImpl Sec,
353                                                uint64_t &Res) const {
354   const coff_section *sec = toSec(Sec);
355   if (!sec)
356     return object_error::parse_failed;
357   Res = uint64_t(1) << (((sec->Characteristics & 0x00F00000) >> 20) - 1);
358   return object_error::success;
359 }
360 
361 error_code COFFObjectFile::isSectionText(DataRefImpl Sec,
362                                          bool &Result) const {
363   const coff_section *sec = toSec(Sec);
364   Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE;
365   return object_error::success;
366 }
367 
368 error_code COFFObjectFile::isSectionData(DataRefImpl Sec,
369                                          bool &Result) const {
370   const coff_section *sec = toSec(Sec);
371   Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA;
372   return object_error::success;
373 }
374 
375 error_code COFFObjectFile::isSectionBSS(DataRefImpl Sec,
376                                         bool &Result) const {
377   const coff_section *sec = toSec(Sec);
378   Result = sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
379   return object_error::success;
380 }
381 
382 error_code COFFObjectFile::sectionContainsSymbol(DataRefImpl Sec,
383                                                  DataRefImpl Symb,
384                                                  bool &Result) const {
385   const coff_section *sec = toSec(Sec);
386   const coff_symbol *symb = toSymb(Symb);
387   const coff_section *symb_sec = 0;
388   if (error_code ec = getSection(symb->SectionNumber, symb_sec)) return ec;
389   if (symb_sec == sec)
390     Result = true;
391   else
392     Result = false;
393   return object_error::success;
394 }
395 
396 relocation_iterator COFFObjectFile::getSectionRelBegin(DataRefImpl Sec) const {
397   const coff_section *sec = toSec(Sec);
398   DataRefImpl ret;
399   std::memset(&ret, 0, sizeof(ret));
400   if (sec->NumberOfRelocations == 0)
401     ret.p = 0;
402   else
403     ret.p = reinterpret_cast<uintptr_t>(base() + sec->PointerToRelocations);
404 
405   return relocation_iterator(RelocationRef(ret, this));
406 }
407 
408 relocation_iterator COFFObjectFile::getSectionRelEnd(DataRefImpl Sec) const {
409   const coff_section *sec = toSec(Sec);
410   DataRefImpl ret;
411   std::memset(&ret, 0, sizeof(ret));
412   if (sec->NumberOfRelocations == 0)
413     ret.p = 0;
414   else
415     ret.p = reinterpret_cast<uintptr_t>(
416               reinterpret_cast<const coff_relocation*>(
417                 base() + sec->PointerToRelocations)
418               + sec->NumberOfRelocations);
419 
420   return relocation_iterator(RelocationRef(ret, this));
421 }
422 
423 COFFObjectFile::COFFObjectFile(MemoryBuffer *Object, error_code &ec)
424   : ObjectFile(Binary::isCOFF, Object, ec)
425   , Header(0)
426   , SectionTable(0)
427   , SymbolTable(0)
428   , StringTable(0)
429   , StringTableSize(0) {
430   // Check that we at least have enough room for a header.
431   if (!checkSize(Data, ec, sizeof(coff_file_header))) return;
432 
433   // The actual starting location of the COFF header in the file. This can be
434   // non-zero in PE/COFF files.
435   uint64_t HeaderStart = 0;
436 
437   // Check if this is a PE/COFF file.
438   if (base()[0] == 0x4d && base()[1] == 0x5a) {
439     // PE/COFF, seek through MS-DOS compatibility stub and 4-byte
440     // PE signature to find 'normal' COFF header.
441     if (!checkSize(Data, ec, 0x3c + 8)) return;
442     HeaderStart = *reinterpret_cast<const ulittle16_t *>(base() + 0x3c);
443     // Check the PE header. ("PE\0\0")
444     if (std::memcmp(base() + HeaderStart, "PE\0\0", 4) != 0) {
445       ec = object_error::parse_failed;
446       return;
447     }
448     HeaderStart += 4; // Skip the PE Header.
449   }
450 
451   Header = reinterpret_cast<const coff_file_header *>(base() + HeaderStart);
452   if (!checkAddr(Data, ec, uintptr_t(Header), sizeof(coff_file_header)))
453     return;
454 
455   SectionTable =
456     reinterpret_cast<const coff_section *>( base()
457                                           + HeaderStart
458                                           + sizeof(coff_file_header)
459                                           + Header->SizeOfOptionalHeader);
460   if (!checkAddr(Data, ec, uintptr_t(SectionTable),
461                  Header->NumberOfSections * sizeof(coff_section)))
462     return;
463 
464   if (Header->PointerToSymbolTable != 0) {
465     SymbolTable =
466       reinterpret_cast<const coff_symbol *>(base()
467                                             + Header->PointerToSymbolTable);
468     if (!checkAddr(Data, ec, uintptr_t(SymbolTable),
469                    Header->NumberOfSymbols * sizeof(coff_symbol)))
470       return;
471 
472     // Find string table.
473     StringTable = reinterpret_cast<const char *>(base())
474                   + Header->PointerToSymbolTable
475                   + Header->NumberOfSymbols * sizeof(coff_symbol);
476     if (!checkAddr(Data, ec, uintptr_t(StringTable), sizeof(ulittle32_t)))
477       return;
478 
479     StringTableSize = *reinterpret_cast<const ulittle32_t *>(StringTable);
480     if (!checkAddr(Data, ec, uintptr_t(StringTable), StringTableSize))
481       return;
482     // Check that the string table is null terminated if has any in it.
483     if (StringTableSize < 4
484         || (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0)) {
485       ec = object_error::parse_failed;
486       return;
487     }
488   }
489 
490   ec = object_error::success;
491 }
492 
493 symbol_iterator COFFObjectFile::begin_symbols() const {
494   DataRefImpl ret;
495   std::memset(&ret, 0, sizeof(DataRefImpl));
496   ret.p = reinterpret_cast<intptr_t>(SymbolTable);
497   return symbol_iterator(SymbolRef(ret, this));
498 }
499 
500 symbol_iterator COFFObjectFile::end_symbols() const {
501   // The symbol table ends where the string table begins.
502   DataRefImpl ret;
503   std::memset(&ret, 0, sizeof(DataRefImpl));
504   ret.p = reinterpret_cast<intptr_t>(StringTable);
505   return symbol_iterator(SymbolRef(ret, this));
506 }
507 
508 symbol_iterator COFFObjectFile::begin_dynamic_symbols() const {
509   // TODO: implement
510   report_fatal_error("Dynamic symbols unimplemented in COFFObjectFile");
511 }
512 
513 symbol_iterator COFFObjectFile::end_dynamic_symbols() const {
514   // TODO: implement
515   report_fatal_error("Dynamic symbols unimplemented in COFFObjectFile");
516 }
517 
518 section_iterator COFFObjectFile::begin_sections() const {
519   DataRefImpl ret;
520   std::memset(&ret, 0, sizeof(DataRefImpl));
521   ret.p = reinterpret_cast<intptr_t>(SectionTable);
522   return section_iterator(SectionRef(ret, this));
523 }
524 
525 section_iterator COFFObjectFile::end_sections() const {
526   DataRefImpl ret;
527   std::memset(&ret, 0, sizeof(DataRefImpl));
528   ret.p = reinterpret_cast<intptr_t>(SectionTable + Header->NumberOfSections);
529   return section_iterator(SectionRef(ret, this));
530 }
531 
532 uint8_t COFFObjectFile::getBytesInAddress() const {
533   return getArch() == Triple::x86_64 ? 8 : 4;
534 }
535 
536 StringRef COFFObjectFile::getFileFormatName() const {
537   switch(Header->Machine) {
538   case COFF::IMAGE_FILE_MACHINE_I386:
539     return "COFF-i386";
540   case COFF::IMAGE_FILE_MACHINE_AMD64:
541     return "COFF-x86-64";
542   default:
543     return "COFF-<unknown arch>";
544   }
545 }
546 
547 unsigned COFFObjectFile::getArch() const {
548   switch(Header->Machine) {
549   case COFF::IMAGE_FILE_MACHINE_I386:
550     return Triple::x86;
551   case COFF::IMAGE_FILE_MACHINE_AMD64:
552     return Triple::x86_64;
553   default:
554     return Triple::UnknownArch;
555   }
556 }
557 
558 error_code COFFObjectFile::getHeader(const coff_file_header *&Res) const {
559   Res = Header;
560   return object_error::success;
561 }
562 
563 error_code COFFObjectFile::getSection(int32_t index,
564                                       const coff_section *&Result) const {
565   // Check for special index values.
566   if (index == COFF::IMAGE_SYM_UNDEFINED ||
567       index == COFF::IMAGE_SYM_ABSOLUTE ||
568       index == COFF::IMAGE_SYM_DEBUG)
569     Result = NULL;
570   else if (index > 0 && index <= Header->NumberOfSections)
571     // We already verified the section table data, so no need to check again.
572     Result = SectionTable + (index - 1);
573   else
574     return object_error::parse_failed;
575   return object_error::success;
576 }
577 
578 error_code COFFObjectFile::getString(uint32_t offset,
579                                      StringRef &Result) const {
580   if (StringTableSize <= 4)
581     // Tried to get a string from an empty string table.
582     return object_error::parse_failed;
583   if (offset >= StringTableSize)
584     return object_error::unexpected_eof;
585   Result = StringRef(StringTable + offset);
586   return object_error::success;
587 }
588 
589 error_code COFFObjectFile::getSymbol(uint32_t index,
590                                      const coff_symbol *&Result) const {
591   if (index < Header->NumberOfSymbols)
592     Result = SymbolTable + index;
593   else
594     return object_error::parse_failed;
595   return object_error::success;
596 }
597 
598 error_code COFFObjectFile::getSymbolName(const coff_symbol *symbol,
599                                          StringRef &Res) const {
600   // Check for string table entry. First 4 bytes are 0.
601   if (symbol->Name.Offset.Zeroes == 0) {
602     uint32_t Offset = symbol->Name.Offset.Offset;
603     if (error_code ec = getString(Offset, Res))
604       return ec;
605     return object_error::success;
606   }
607 
608   if (symbol->Name.ShortName[7] == 0)
609     // Null terminated, let ::strlen figure out the length.
610     Res = StringRef(symbol->Name.ShortName);
611   else
612     // Not null terminated, use all 8 bytes.
613     Res = StringRef(symbol->Name.ShortName, 8);
614   return object_error::success;
615 }
616 
617 const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const {
618   return reinterpret_cast<const coff_relocation*>(Rel.p);
619 }
620 error_code COFFObjectFile::getRelocationNext(DataRefImpl Rel,
621                                              RelocationRef &Res) const {
622   Rel.p = reinterpret_cast<uintptr_t>(
623             reinterpret_cast<const coff_relocation*>(Rel.p) + 1);
624   Res = RelocationRef(Rel, this);
625   return object_error::success;
626 }
627 error_code COFFObjectFile::getRelocationAddress(DataRefImpl Rel,
628                                                 uint64_t &Res) const {
629   Res = toRel(Rel)->VirtualAddress;
630   return object_error::success;
631 }
632 error_code COFFObjectFile::getRelocationOffset(DataRefImpl Rel,
633                                                uint64_t &Res) const {
634   Res = toRel(Rel)->VirtualAddress;
635   return object_error::success;
636 }
637 error_code COFFObjectFile::getRelocationSymbol(DataRefImpl Rel,
638                                                SymbolRef &Res) const {
639   const coff_relocation* R = toRel(Rel);
640   DataRefImpl Symb;
641   std::memset(&Symb, 0, sizeof(Symb));
642   Symb.p = reinterpret_cast<uintptr_t>(SymbolTable + R->SymbolTableIndex);
643   Res = SymbolRef(Symb, this);
644   return object_error::success;
645 }
646 error_code COFFObjectFile::getRelocationType(DataRefImpl Rel,
647                                              uint64_t &Res) const {
648   const coff_relocation* R = toRel(Rel);
649   Res = R->Type;
650   return object_error::success;
651 }
652 
653 #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(enum) \
654   case COFF::enum: res = #enum; break;
655 
656 error_code COFFObjectFile::getRelocationTypeName(DataRefImpl Rel,
657                                           SmallVectorImpl<char> &Result) const {
658   const coff_relocation *reloc = toRel(Rel);
659   StringRef res;
660   switch (Header->Machine) {
661   case COFF::IMAGE_FILE_MACHINE_AMD64:
662     switch (reloc->Type) {
663     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE);
664     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR64);
665     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32);
666     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32NB);
667     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32);
668     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_1);
669     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_2);
670     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_3);
671     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_4);
672     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_5);
673     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECTION);
674     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL);
675     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL7);
676     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_TOKEN);
677     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SREL32);
678     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_PAIR);
679     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SSPAN32);
680     default:
681       res = "Unknown";
682     }
683     break;
684   case COFF::IMAGE_FILE_MACHINE_I386:
685     switch (reloc->Type) {
686     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_ABSOLUTE);
687     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR16);
688     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL16);
689     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32);
690     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32NB);
691     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SEG12);
692     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECTION);
693     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL);
694     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_TOKEN);
695     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL7);
696     LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL32);
697     default:
698       res = "Unknown";
699     }
700     break;
701   default:
702     res = "Unknown";
703   }
704   Result.append(res.begin(), res.end());
705   return object_error::success;
706 }
707 
708 #undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME
709 
710 error_code COFFObjectFile::getRelocationAdditionalInfo(DataRefImpl Rel,
711                                                        int64_t &Res) const {
712   Res = 0;
713   return object_error::success;
714 }
715 error_code COFFObjectFile::getRelocationValueString(DataRefImpl Rel,
716                                           SmallVectorImpl<char> &Result) const {
717   const coff_relocation *reloc = toRel(Rel);
718   const coff_symbol *symb = 0;
719   if (error_code ec = getSymbol(reloc->SymbolTableIndex, symb)) return ec;
720   DataRefImpl sym;
721   ::memset(&sym, 0, sizeof(sym));
722   sym.p = reinterpret_cast<uintptr_t>(symb);
723   StringRef symname;
724   if (error_code ec = getSymbolName(sym, symname)) return ec;
725   Result.append(symname.begin(), symname.end());
726   return object_error::success;
727 }
728 
729 namespace llvm {
730 
731   ObjectFile *ObjectFile::createCOFFObjectFile(MemoryBuffer *Object) {
732     error_code ec;
733     return new COFFObjectFile(Object, ec);
734   }
735 
736 } // end namespace llvm
737