Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 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 | |
Michael J. Spencer | ec29b12 | 2011-06-25 17:54:50 +0000 | [diff] [blame] | 14 | #include "llvm/Object/COFF.h" |
Michael J. Spencer | 9da9e69 | 2012-03-19 20:27:37 +0000 | [diff] [blame] | 15 | #include "llvm/ADT/ArrayRef.h" |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 16 | #include "llvm/ADT/SmallString.h" |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 17 | #include "llvm/ADT/StringSwitch.h" |
| 18 | #include "llvm/ADT/Triple.h" |
Rui Ueyama | f078eff | 2014-03-18 23:37:53 +0000 | [diff] [blame] | 19 | #include "llvm/Support/COFF.h" |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 20 | #include "llvm/Support/Debug.h" |
| 21 | #include "llvm/Support/raw_ostream.h" |
Will Dietz | 981af00 | 2013-10-12 00:55:57 +0000 | [diff] [blame] | 22 | #include <cctype> |
Nico Rieck | 9d2c15e | 2014-02-22 16:12:20 +0000 | [diff] [blame] | 23 | #include <limits> |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 24 | |
| 25 | using namespace llvm; |
| 26 | using namespace object; |
| 27 | |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 28 | using support::ulittle16_t; |
| 29 | using support::ulittle32_t; |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 30 | using support::ulittle64_t; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 31 | using support::little16_t; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 32 | |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 33 | // Returns false if size is greater than the buffer size. And sets ec. |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 34 | static bool checkSize(MemoryBufferRef M, std::error_code &EC, uint64_t Size) { |
Rafael Espindola | c3f9b5a | 2014-06-23 21:53:12 +0000 | [diff] [blame] | 35 | if (M.getBufferSize() < Size) { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 36 | EC = object_error::unexpected_eof; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 37 | return false; |
| 38 | } |
| 39 | return true; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 40 | } |
| 41 | |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 42 | // Sets Obj unless any bytes in [addr, addr + size) fall outsize of m. |
| 43 | // Returns unexpected_eof if error. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 44 | template <typename T> |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 45 | static std::error_code getObject(const T *&Obj, MemoryBufferRef M, |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 46 | const uint8_t *Ptr, |
| 47 | const size_t Size = sizeof(T)) { |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 48 | uintptr_t Addr = uintptr_t(Ptr); |
Rafael Espindola | c3f9b5a | 2014-06-23 21:53:12 +0000 | [diff] [blame] | 49 | if (Addr + Size < Addr || Addr + Size < Size || |
| 50 | Addr + Size > uintptr_t(M.getBufferEnd())) { |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 51 | return object_error::unexpected_eof; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 52 | } |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 53 | Obj = reinterpret_cast<const T *>(Addr); |
| 54 | return object_error::success; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 55 | } |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 56 | |
Nico Rieck | 9d2c15e | 2014-02-22 16:12:20 +0000 | [diff] [blame] | 57 | // Decode a string table entry in base 64 (//AAAAAA). Expects \arg Str without |
| 58 | // prefixed slashes. |
| 59 | static bool decodeBase64StringEntry(StringRef Str, uint32_t &Result) { |
| 60 | assert(Str.size() <= 6 && "String too long, possible overflow."); |
| 61 | if (Str.size() > 6) |
| 62 | return true; |
| 63 | |
| 64 | uint64_t Value = 0; |
| 65 | while (!Str.empty()) { |
| 66 | unsigned CharVal; |
| 67 | if (Str[0] >= 'A' && Str[0] <= 'Z') // 0..25 |
| 68 | CharVal = Str[0] - 'A'; |
| 69 | else if (Str[0] >= 'a' && Str[0] <= 'z') // 26..51 |
| 70 | CharVal = Str[0] - 'a' + 26; |
| 71 | else if (Str[0] >= '0' && Str[0] <= '9') // 52..61 |
| 72 | CharVal = Str[0] - '0' + 52; |
| 73 | else if (Str[0] == '+') // 62 |
Rui Ueyama | 5500b07 | 2014-02-25 23:49:11 +0000 | [diff] [blame] | 74 | CharVal = 62; |
Nico Rieck | 9d2c15e | 2014-02-22 16:12:20 +0000 | [diff] [blame] | 75 | else if (Str[0] == '/') // 63 |
Rui Ueyama | 5500b07 | 2014-02-25 23:49:11 +0000 | [diff] [blame] | 76 | CharVal = 63; |
Nico Rieck | 9d2c15e | 2014-02-22 16:12:20 +0000 | [diff] [blame] | 77 | else |
| 78 | return true; |
| 79 | |
| 80 | Value = (Value * 64) + CharVal; |
| 81 | Str = Str.substr(1); |
| 82 | } |
| 83 | |
| 84 | if (Value > std::numeric_limits<uint32_t>::max()) |
| 85 | return true; |
| 86 | |
| 87 | Result = static_cast<uint32_t>(Value); |
| 88 | return false; |
| 89 | } |
| 90 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 91 | template <typename coff_symbol_type> |
| 92 | const coff_symbol_type *COFFObjectFile::toSymb(DataRefImpl Ref) const { |
| 93 | const coff_symbol_type *Addr = |
| 94 | reinterpret_cast<const coff_symbol_type *>(Ref.p); |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 95 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 96 | #ifndef NDEBUG |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 97 | // Verify that the symbol points to a valid entry in the symbol table. |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 98 | uintptr_t Offset = uintptr_t(Addr) - uintptr_t(base()); |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 99 | if (Offset < getPointerToSymbolTable() || |
| 100 | Offset >= getPointerToSymbolTable() + |
| 101 | (getNumberOfSymbols() * sizeof(coff_symbol_type))) |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 102 | report_fatal_error("Symbol was outside of symbol table."); |
| 103 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 104 | assert((Offset - getPointerToSymbolTable()) % sizeof(coff_symbol_type) == 0 && |
| 105 | "Symbol did not point to the beginning of a symbol"); |
| 106 | #endif |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 107 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 108 | return Addr; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 109 | } |
| 110 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 111 | const coff_section *COFFObjectFile::toSec(DataRefImpl Ref) const { |
| 112 | const coff_section *Addr = reinterpret_cast<const coff_section*>(Ref.p); |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 113 | |
| 114 | # ifndef NDEBUG |
| 115 | // Verify that the section points to a valid entry in the section table. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 116 | if (Addr < SectionTable || Addr >= (SectionTable + getNumberOfSections())) |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 117 | report_fatal_error("Section was outside of section table."); |
| 118 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 119 | uintptr_t Offset = uintptr_t(Addr) - uintptr_t(SectionTable); |
| 120 | assert(Offset % sizeof(coff_section) == 0 && |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 121 | "Section did not point to the beginning of a section"); |
| 122 | # endif |
| 123 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 124 | return Addr; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 125 | } |
| 126 | |
Rafael Espindola | 5e812af | 2014-01-30 02:49:50 +0000 | [diff] [blame] | 127 | void COFFObjectFile::moveSymbolNext(DataRefImpl &Ref) const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 128 | if (SymbolTable16) { |
| 129 | const coff_symbol16 *Symb = toSymb<coff_symbol16>(Ref); |
| 130 | Symb += 1 + Symb->NumberOfAuxSymbols; |
| 131 | Ref.p = reinterpret_cast<uintptr_t>(Symb); |
| 132 | } else if (SymbolTable32) { |
| 133 | const coff_symbol32 *Symb = toSymb<coff_symbol32>(Ref); |
| 134 | Symb += 1 + Symb->NumberOfAuxSymbols; |
| 135 | Ref.p = reinterpret_cast<uintptr_t>(Symb); |
| 136 | } else { |
| 137 | llvm_unreachable("no symbol table pointer!"); |
| 138 | } |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 139 | } |
| 140 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 141 | std::error_code COFFObjectFile::getSymbolName(DataRefImpl Ref, |
| 142 | StringRef &Result) const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 143 | COFFSymbolRef Symb = getCOFFSymbol(Ref); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 144 | return getSymbolName(Symb, Result); |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 145 | } |
| 146 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 147 | std::error_code COFFObjectFile::getSymbolAddress(DataRefImpl Ref, |
| 148 | uint64_t &Result) const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 149 | COFFSymbolRef Symb = getCOFFSymbol(Ref); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 150 | const coff_section *Section = nullptr; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 151 | if (std::error_code EC = getSection(Symb.getSectionNumber(), Section)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 152 | return EC; |
Rafael Espindola | e62ab11 | 2013-11-02 18:07:48 +0000 | [diff] [blame] | 153 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 154 | if (Symb.getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED) |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 155 | Result = UnknownAddressOrSize; |
| 156 | else if (Section) |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 157 | Result = Section->VirtualAddress + Symb.getValue(); |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 158 | else |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 159 | Result = Symb.getValue(); |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 160 | return object_error::success; |
| 161 | } |
| 162 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 163 | std::error_code COFFObjectFile::getSymbolType(DataRefImpl Ref, |
| 164 | SymbolRef::Type &Result) const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 165 | COFFSymbolRef Symb = getCOFFSymbol(Ref); |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 166 | Result = SymbolRef::ST_Other; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 167 | |
| 168 | if (Symb.getStorageClass() == COFF::IMAGE_SYM_CLASS_EXTERNAL && |
| 169 | Symb.getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED) { |
David Meyer | 7e4b976 | 2012-02-29 02:11:55 +0000 | [diff] [blame] | 170 | Result = SymbolRef::ST_Unknown; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 171 | } else if (Symb.isFunctionDefinition()) { |
Rui Ueyama | 5efa665 | 2014-01-16 20:22:55 +0000 | [diff] [blame] | 172 | Result = SymbolRef::ST_Function; |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 173 | } else { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 174 | uint32_t Characteristics = 0; |
| 175 | if (!COFF::isReservedSectionNumber(Symb.getSectionNumber())) { |
| 176 | const coff_section *Section = nullptr; |
| 177 | if (std::error_code EC = getSection(Symb.getSectionNumber(), Section)) |
| 178 | return EC; |
| 179 | Characteristics = Section->Characteristics; |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 180 | } |
Rui Ueyama | 5efa665 | 2014-01-16 20:22:55 +0000 | [diff] [blame] | 181 | if (Characteristics & COFF::IMAGE_SCN_MEM_READ && |
| 182 | ~Characteristics & COFF::IMAGE_SCN_MEM_WRITE) // Read only. |
| 183 | Result = SymbolRef::ST_Data; |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 184 | } |
| 185 | return object_error::success; |
| 186 | } |
| 187 | |
Rafael Espindola | 20122a4 | 2014-01-31 20:57:12 +0000 | [diff] [blame] | 188 | uint32_t COFFObjectFile::getSymbolFlags(DataRefImpl Ref) const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 189 | COFFSymbolRef Symb = getCOFFSymbol(Ref); |
Rafael Espindola | 20122a4 | 2014-01-31 20:57:12 +0000 | [diff] [blame] | 190 | uint32_t Result = SymbolRef::SF_None; |
Benjamin Kramer | 75d1cf33 | 2011-09-14 01:22:52 +0000 | [diff] [blame] | 191 | |
Rafael Espindola | 975e115 | 2014-02-04 22:50:47 +0000 | [diff] [blame] | 192 | // TODO: Correctly set SF_FormatSpecific, SF_Common |
David Meyer | 7e4b976 | 2012-02-29 02:11:55 +0000 | [diff] [blame] | 193 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 194 | if (Symb.getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED) { |
| 195 | if (Symb.getValue() == 0) |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 196 | Result |= SymbolRef::SF_Undefined; |
| 197 | else |
| 198 | Result |= SymbolRef::SF_Common; |
| 199 | } |
| 200 | |
David Meyer | 1df4b84 | 2012-02-28 23:47:53 +0000 | [diff] [blame] | 201 | |
| 202 | // TODO: This are certainly too restrictive. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 203 | if (Symb.getStorageClass() == COFF::IMAGE_SYM_CLASS_EXTERNAL) |
David Meyer | 1df4b84 | 2012-02-28 23:47:53 +0000 | [diff] [blame] | 204 | Result |= SymbolRef::SF_Global; |
| 205 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 206 | if (Symb.getStorageClass() == COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL) |
David Meyer | 1df4b84 | 2012-02-28 23:47:53 +0000 | [diff] [blame] | 207 | Result |= SymbolRef::SF_Weak; |
| 208 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 209 | if (Symb.getSectionNumber() == COFF::IMAGE_SYM_ABSOLUTE) |
David Meyer | 1df4b84 | 2012-02-28 23:47:53 +0000 | [diff] [blame] | 210 | Result |= SymbolRef::SF_Absolute; |
| 211 | |
Rafael Espindola | 20122a4 | 2014-01-31 20:57:12 +0000 | [diff] [blame] | 212 | return Result; |
Michael J. Spencer | 0175975 | 2011-10-17 23:54:22 +0000 | [diff] [blame] | 213 | } |
| 214 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 215 | std::error_code COFFObjectFile::getSymbolSize(DataRefImpl Ref, |
| 216 | uint64_t &Result) const { |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 217 | // FIXME: Return the correct size. This requires looking at all the symbols |
| 218 | // in the same section as this symbol, and looking for either the next |
| 219 | // symbol, or the end of the section. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 220 | COFFSymbolRef Symb = getCOFFSymbol(Ref); |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 221 | const coff_section *Section = nullptr; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 222 | if (std::error_code EC = getSection(Symb.getSectionNumber(), Section)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 223 | return EC; |
Rafael Espindola | e62ab11 | 2013-11-02 18:07:48 +0000 | [diff] [blame] | 224 | |
Rafael Espindola | 8280fbb | 2014-10-08 17:37:19 +0000 | [diff] [blame] | 225 | if (Symb.getSectionNumber() == COFF::IMAGE_SYM_UNDEFINED) { |
| 226 | if (Symb.getValue() == 0) |
| 227 | Result = UnknownAddressOrSize; |
| 228 | else |
| 229 | Result = Symb.getValue(); |
| 230 | } else if (Section) { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 231 | Result = Section->SizeOfRawData - Symb.getValue(); |
Rafael Espindola | 8280fbb | 2014-10-08 17:37:19 +0000 | [diff] [blame] | 232 | } else { |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 233 | Result = 0; |
Rafael Espindola | 8280fbb | 2014-10-08 17:37:19 +0000 | [diff] [blame] | 234 | } |
| 235 | |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 236 | return object_error::success; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 237 | } |
| 238 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 239 | std::error_code |
| 240 | COFFObjectFile::getSymbolSection(DataRefImpl Ref, |
| 241 | section_iterator &Result) const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 242 | COFFSymbolRef Symb = getCOFFSymbol(Ref); |
| 243 | if (COFF::isReservedSectionNumber(Symb.getSectionNumber())) { |
Rafael Espindola | b5155a5 | 2014-02-10 20:24:04 +0000 | [diff] [blame] | 244 | Result = section_end(); |
Rui Ueyama | f078eff | 2014-03-18 23:37:53 +0000 | [diff] [blame] | 245 | } else { |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 246 | const coff_section *Sec = nullptr; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 247 | if (std::error_code EC = getSection(Symb.getSectionNumber(), Sec)) |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 248 | return EC; |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 249 | DataRefImpl Ref; |
| 250 | Ref.p = reinterpret_cast<uintptr_t>(Sec); |
| 251 | Result = section_iterator(SectionRef(Ref, this)); |
Michael J. Spencer | 321731539 | 2011-10-17 23:54:46 +0000 | [diff] [blame] | 252 | } |
| 253 | return object_error::success; |
| 254 | } |
| 255 | |
Rafael Espindola | 5e812af | 2014-01-30 02:49:50 +0000 | [diff] [blame] | 256 | void COFFObjectFile::moveSectionNext(DataRefImpl &Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 257 | const coff_section *Sec = toSec(Ref); |
| 258 | Sec += 1; |
| 259 | Ref.p = reinterpret_cast<uintptr_t>(Sec); |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 260 | } |
| 261 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 262 | std::error_code COFFObjectFile::getSectionName(DataRefImpl Ref, |
| 263 | StringRef &Result) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 264 | const coff_section *Sec = toSec(Ref); |
| 265 | return getSectionName(Sec, Result); |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 266 | } |
| 267 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 268 | uint64_t COFFObjectFile::getSectionAddress(DataRefImpl Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 269 | const coff_section *Sec = toSec(Ref); |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 270 | return Sec->VirtualAddress; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 271 | } |
| 272 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 273 | uint64_t COFFObjectFile::getSectionSize(DataRefImpl Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 274 | const coff_section *Sec = toSec(Ref); |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 275 | return Sec->SizeOfRawData; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 276 | } |
| 277 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 278 | std::error_code COFFObjectFile::getSectionContents(DataRefImpl Ref, |
| 279 | StringRef &Result) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 280 | const coff_section *Sec = toSec(Ref); |
Michael J. Spencer | 9da9e69 | 2012-03-19 20:27:37 +0000 | [diff] [blame] | 281 | ArrayRef<uint8_t> Res; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 282 | std::error_code EC = getSectionContents(Sec, Res); |
Michael J. Spencer | 9da9e69 | 2012-03-19 20:27:37 +0000 | [diff] [blame] | 283 | Result = StringRef(reinterpret_cast<const char*>(Res.data()), Res.size()); |
| 284 | return EC; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 285 | } |
| 286 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 287 | uint64_t COFFObjectFile::getSectionAlignment(DataRefImpl Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 288 | const coff_section *Sec = toSec(Ref); |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 289 | return uint64_t(1) << (((Sec->Characteristics & 0x00F00000) >> 20) - 1); |
Michael J. Spencer | 7989460 | 2011-10-10 21:55:43 +0000 | [diff] [blame] | 290 | } |
| 291 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 292 | bool COFFObjectFile::isSectionText(DataRefImpl Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 293 | const coff_section *Sec = toSec(Ref); |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 294 | return Sec->Characteristics & COFF::IMAGE_SCN_CNT_CODE; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 295 | } |
| 296 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 297 | bool COFFObjectFile::isSectionData(DataRefImpl Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 298 | const coff_section *Sec = toSec(Ref); |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 299 | return Sec->Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA; |
Michael J. Spencer | 800619f | 2011-09-28 20:57:30 +0000 | [diff] [blame] | 300 | } |
| 301 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 302 | bool COFFObjectFile::isSectionBSS(DataRefImpl Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 303 | const coff_section *Sec = toSec(Ref); |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 304 | return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; |
Michael J. Spencer | 800619f | 2011-09-28 20:57:30 +0000 | [diff] [blame] | 305 | } |
| 306 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 307 | bool COFFObjectFile::isSectionRequiredForExecution(DataRefImpl Ref) const { |
Preston Gurd | 2138ef6 | 2012-04-12 20:13:57 +0000 | [diff] [blame] | 308 | // FIXME: Unimplemented |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 309 | return true; |
Preston Gurd | 2138ef6 | 2012-04-12 20:13:57 +0000 | [diff] [blame] | 310 | } |
| 311 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 312 | bool COFFObjectFile::isSectionVirtual(DataRefImpl Ref) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 313 | const coff_section *Sec = toSec(Ref); |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 314 | return Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; |
Preston Gurd | 2138ef6 | 2012-04-12 20:13:57 +0000 | [diff] [blame] | 315 | } |
| 316 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 317 | bool COFFObjectFile::isSectionZeroInit(DataRefImpl Ref) const { |
Andrew Kaylor | b96a320 | 2012-10-10 01:45:52 +0000 | [diff] [blame] | 318 | // FIXME: Unimplemented. |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 319 | return false; |
Preston Gurd | 2138ef6 | 2012-04-12 20:13:57 +0000 | [diff] [blame] | 320 | } |
| 321 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 322 | bool COFFObjectFile::isSectionReadOnlyData(DataRefImpl Ref) const { |
Andrew Kaylor | 3f31fa0 | 2012-10-10 01:41:33 +0000 | [diff] [blame] | 323 | // FIXME: Unimplemented. |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 324 | return false; |
Andrew Kaylor | 3f31fa0 | 2012-10-10 01:41:33 +0000 | [diff] [blame] | 325 | } |
| 326 | |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 327 | bool COFFObjectFile::sectionContainsSymbol(DataRefImpl SecRef, |
| 328 | DataRefImpl SymbRef) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 329 | const coff_section *Sec = toSec(SecRef); |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 330 | COFFSymbolRef Symb = getCOFFSymbol(SymbRef); |
Rafael Espindola | a926086 | 2014-10-07 20:42:47 +0000 | [diff] [blame] | 331 | int32_t SecNumber = (Sec - SectionTable) + 1; |
Rafael Espindola | 8029127 | 2014-10-08 15:28:58 +0000 | [diff] [blame] | 332 | return SecNumber == Symb.getSectionNumber(); |
Benjamin Kramer | f6f3e81 | 2011-07-15 18:39:21 +0000 | [diff] [blame] | 333 | } |
| 334 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 335 | relocation_iterator COFFObjectFile::section_rel_begin(DataRefImpl Ref) const { |
| 336 | const coff_section *Sec = toSec(Ref); |
| 337 | DataRefImpl Ret; |
Rui Ueyama | 827c8a2 | 2014-03-21 00:44:19 +0000 | [diff] [blame] | 338 | if (Sec->NumberOfRelocations == 0) { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 339 | Ret.p = 0; |
Rui Ueyama | 827c8a2 | 2014-03-21 00:44:19 +0000 | [diff] [blame] | 340 | } else { |
| 341 | auto begin = reinterpret_cast<const coff_relocation*>( |
| 342 | base() + Sec->PointerToRelocations); |
| 343 | if (Sec->hasExtendedRelocations()) { |
| 344 | // Skip the first relocation entry repurposed to store the number of |
| 345 | // relocations. |
| 346 | begin++; |
| 347 | } |
| 348 | Ret.p = reinterpret_cast<uintptr_t>(begin); |
| 349 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 350 | return relocation_iterator(RelocationRef(Ret, this)); |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 351 | } |
| 352 | |
Rui Ueyama | 827c8a2 | 2014-03-21 00:44:19 +0000 | [diff] [blame] | 353 | static uint32_t getNumberOfRelocations(const coff_section *Sec, |
| 354 | const uint8_t *base) { |
| 355 | // The field for the number of relocations in COFF section table is only |
| 356 | // 16-bit wide. If a section has more than 65535 relocations, 0xFFFF is set to |
| 357 | // NumberOfRelocations field, and the actual relocation count is stored in the |
| 358 | // VirtualAddress field in the first relocation entry. |
| 359 | if (Sec->hasExtendedRelocations()) { |
| 360 | auto *FirstReloc = reinterpret_cast<const coff_relocation*>( |
| 361 | base + Sec->PointerToRelocations); |
| 362 | return FirstReloc->VirtualAddress; |
| 363 | } |
| 364 | return Sec->NumberOfRelocations; |
| 365 | } |
| 366 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 367 | relocation_iterator COFFObjectFile::section_rel_end(DataRefImpl Ref) const { |
| 368 | const coff_section *Sec = toSec(Ref); |
| 369 | DataRefImpl Ret; |
Rui Ueyama | 827c8a2 | 2014-03-21 00:44:19 +0000 | [diff] [blame] | 370 | if (Sec->NumberOfRelocations == 0) { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 371 | Ret.p = 0; |
Rui Ueyama | 827c8a2 | 2014-03-21 00:44:19 +0000 | [diff] [blame] | 372 | } else { |
| 373 | auto begin = reinterpret_cast<const coff_relocation*>( |
| 374 | base() + Sec->PointerToRelocations); |
| 375 | uint32_t NumReloc = getNumberOfRelocations(Sec, base()); |
| 376 | Ret.p = reinterpret_cast<uintptr_t>(begin + NumReloc); |
| 377 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 378 | return relocation_iterator(RelocationRef(Ret, this)); |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 379 | } |
| 380 | |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 381 | // Initialize the pointer to the symbol table. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 382 | std::error_code COFFObjectFile::initSymbolTablePtr() { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 383 | if (COFFHeader) |
| 384 | if (std::error_code EC = |
| 385 | getObject(SymbolTable16, Data, base() + getPointerToSymbolTable(), |
| 386 | getNumberOfSymbols() * getSymbolTableEntrySize())) |
| 387 | return EC; |
| 388 | |
| 389 | if (COFFBigObjHeader) |
| 390 | if (std::error_code EC = |
| 391 | getObject(SymbolTable32, Data, base() + getPointerToSymbolTable(), |
| 392 | getNumberOfSymbols() * getSymbolTableEntrySize())) |
| 393 | return EC; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 394 | |
| 395 | // Find string table. The first four byte of the string table contains the |
| 396 | // total size of the string table, including the size field itself. If the |
| 397 | // string table is empty, the value of the first four byte would be 4. |
| 398 | const uint8_t *StringTableAddr = |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 399 | base() + getPointerToSymbolTable() + |
| 400 | getNumberOfSymbols() * getSymbolTableEntrySize(); |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 401 | const ulittle32_t *StringTableSizePtr; |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 402 | if (std::error_code EC = getObject(StringTableSizePtr, Data, StringTableAddr)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 403 | return EC; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 404 | StringTableSize = *StringTableSizePtr; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 405 | if (std::error_code EC = |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 406 | getObject(StringTable, Data, StringTableAddr, StringTableSize)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 407 | return EC; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 408 | |
Nico Rieck | 773a579 | 2014-02-26 19:51:44 +0000 | [diff] [blame] | 409 | // Treat table sizes < 4 as empty because contrary to the PECOFF spec, some |
| 410 | // tools like cvtres write a size of 0 for an empty table instead of 4. |
| 411 | if (StringTableSize < 4) |
| 412 | StringTableSize = 4; |
| 413 | |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 414 | // Check that the string table is null terminated if has any in it. |
Nico Rieck | 773a579 | 2014-02-26 19:51:44 +0000 | [diff] [blame] | 415 | if (StringTableSize > 4 && StringTable[StringTableSize - 1] != 0) |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 416 | return object_error::parse_failed; |
| 417 | return object_error::success; |
| 418 | } |
| 419 | |
Rui Ueyama | 215a586 | 2014-02-20 06:51:07 +0000 | [diff] [blame] | 420 | // Returns the file offset for the given VA. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 421 | std::error_code COFFObjectFile::getVaPtr(uint64_t Addr, uintptr_t &Res) const { |
Rui Ueyama | b6eb264 | 2014-02-20 19:32:00 +0000 | [diff] [blame] | 422 | uint64_t ImageBase = PE32Header ? (uint64_t)PE32Header->ImageBase |
| 423 | : (uint64_t)PE32PlusHeader->ImageBase; |
Rui Ueyama | b7a4008 | 2014-02-20 19:14:56 +0000 | [diff] [blame] | 424 | uint64_t Rva = Addr - ImageBase; |
| 425 | assert(Rva <= UINT32_MAX); |
| 426 | return getRvaPtr((uint32_t)Rva, Res); |
Rui Ueyama | 215a586 | 2014-02-20 06:51:07 +0000 | [diff] [blame] | 427 | } |
| 428 | |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 429 | // Returns the file offset for the given RVA. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 430 | std::error_code COFFObjectFile::getRvaPtr(uint32_t Addr, uintptr_t &Res) const { |
Alexey Samsonov | 27dc839 | 2014-03-18 06:53:02 +0000 | [diff] [blame] | 431 | for (const SectionRef &S : sections()) { |
| 432 | const coff_section *Section = getCOFFSection(S); |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 433 | uint32_t SectionStart = Section->VirtualAddress; |
| 434 | uint32_t SectionEnd = Section->VirtualAddress + Section->VirtualSize; |
Rui Ueyama | 215a586 | 2014-02-20 06:51:07 +0000 | [diff] [blame] | 435 | if (SectionStart <= Addr && Addr < SectionEnd) { |
| 436 | uint32_t Offset = Addr - SectionStart; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 437 | Res = uintptr_t(base()) + Section->PointerToRawData + Offset; |
| 438 | return object_error::success; |
| 439 | } |
| 440 | } |
| 441 | return object_error::parse_failed; |
| 442 | } |
| 443 | |
| 444 | // Returns hint and name fields, assuming \p Rva is pointing to a Hint/Name |
| 445 | // table entry. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 446 | std::error_code COFFObjectFile::getHintName(uint32_t Rva, uint16_t &Hint, |
| 447 | StringRef &Name) const { |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 448 | uintptr_t IntPtr = 0; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 449 | if (std::error_code EC = getRvaPtr(Rva, IntPtr)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 450 | return EC; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 451 | const uint8_t *Ptr = reinterpret_cast<const uint8_t *>(IntPtr); |
| 452 | Hint = *reinterpret_cast<const ulittle16_t *>(Ptr); |
| 453 | Name = StringRef(reinterpret_cast<const char *>(Ptr + 2)); |
| 454 | return object_error::success; |
| 455 | } |
| 456 | |
| 457 | // Find the import table. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 458 | std::error_code COFFObjectFile::initImportTablePtr() { |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 459 | // First, we get the RVA of the import table. If the file lacks a pointer to |
| 460 | // the import table, do nothing. |
| 461 | const data_directory *DataEntry; |
| 462 | if (getDataDirectory(COFF::IMPORT_TABLE, DataEntry)) |
| 463 | return object_error::success; |
| 464 | |
| 465 | // Do nothing if the pointer to import table is NULL. |
| 466 | if (DataEntry->RelativeVirtualAddress == 0) |
| 467 | return object_error::success; |
| 468 | |
| 469 | uint32_t ImportTableRva = DataEntry->RelativeVirtualAddress; |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 470 | // -1 because the last entry is the null entry. |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 471 | NumberOfImportDirectory = DataEntry->Size / |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 472 | sizeof(import_directory_table_entry) - 1; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 473 | |
| 474 | // Find the section that contains the RVA. This is needed because the RVA is |
| 475 | // the import table's memory address which is different from its file offset. |
| 476 | uintptr_t IntPtr = 0; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 477 | if (std::error_code EC = getRvaPtr(ImportTableRva, IntPtr)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 478 | return EC; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 479 | ImportDirectory = reinterpret_cast< |
| 480 | const import_directory_table_entry *>(IntPtr); |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 481 | return object_error::success; |
| 482 | } |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 483 | |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 484 | // Initializes DelayImportDirectory and NumberOfDelayImportDirectory. |
| 485 | std::error_code COFFObjectFile::initDelayImportTablePtr() { |
| 486 | const data_directory *DataEntry; |
| 487 | if (getDataDirectory(COFF::DELAY_IMPORT_DESCRIPTOR, DataEntry)) |
| 488 | return object_error::success; |
| 489 | if (DataEntry->RelativeVirtualAddress == 0) |
| 490 | return object_error::success; |
| 491 | |
| 492 | uint32_t RVA = DataEntry->RelativeVirtualAddress; |
| 493 | NumberOfDelayImportDirectory = DataEntry->Size / |
| 494 | sizeof(delay_import_directory_table_entry) - 1; |
| 495 | |
| 496 | uintptr_t IntPtr = 0; |
| 497 | if (std::error_code EC = getRvaPtr(RVA, IntPtr)) |
| 498 | return EC; |
| 499 | DelayImportDirectory = reinterpret_cast< |
| 500 | const delay_import_directory_table_entry *>(IntPtr); |
| 501 | return object_error::success; |
| 502 | } |
| 503 | |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 504 | // Find the export table. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 505 | std::error_code COFFObjectFile::initExportTablePtr() { |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 506 | // First, we get the RVA of the export table. If the file lacks a pointer to |
| 507 | // the export table, do nothing. |
| 508 | const data_directory *DataEntry; |
| 509 | if (getDataDirectory(COFF::EXPORT_TABLE, DataEntry)) |
| 510 | return object_error::success; |
| 511 | |
| 512 | // Do nothing if the pointer to export table is NULL. |
| 513 | if (DataEntry->RelativeVirtualAddress == 0) |
| 514 | return object_error::success; |
| 515 | |
| 516 | uint32_t ExportTableRva = DataEntry->RelativeVirtualAddress; |
| 517 | uintptr_t IntPtr = 0; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 518 | if (std::error_code EC = getRvaPtr(ExportTableRva, IntPtr)) |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 519 | return EC; |
Rui Ueyama | 24fc2d6 | 2014-01-17 22:11:27 +0000 | [diff] [blame] | 520 | ExportDirectory = |
| 521 | reinterpret_cast<const export_directory_table_entry *>(IntPtr); |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 522 | return object_error::success; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 523 | } |
| 524 | |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 525 | COFFObjectFile::COFFObjectFile(MemoryBufferRef Object, std::error_code &EC) |
| 526 | : ObjectFile(Binary::ID_COFF, Object), COFFHeader(nullptr), |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 527 | COFFBigObjHeader(nullptr), PE32Header(nullptr), PE32PlusHeader(nullptr), |
| 528 | DataDirectory(nullptr), SectionTable(nullptr), SymbolTable16(nullptr), |
| 529 | SymbolTable32(nullptr), StringTable(nullptr), StringTableSize(0), |
| 530 | ImportDirectory(nullptr), NumberOfImportDirectory(0), |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 531 | DelayImportDirectory(nullptr), NumberOfDelayImportDirectory(0), |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 532 | ExportDirectory(nullptr) { |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 533 | // Check that we at least have enough room for a header. |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 534 | if (!checkSize(Data, EC, sizeof(coff_file_header))) |
Rafael Espindola | c3f9b5a | 2014-06-23 21:53:12 +0000 | [diff] [blame] | 535 | return; |
Eric Christopher | ee066fc | 2011-04-03 22:53:19 +0000 | [diff] [blame] | 536 | |
Rui Ueyama | 82ebd8e | 2013-06-12 19:10:33 +0000 | [diff] [blame] | 537 | // The current location in the file where we are looking at. |
| 538 | uint64_t CurPtr = 0; |
| 539 | |
| 540 | // PE header is optional and is present only in executables. If it exists, |
| 541 | // it is placed right after COFF header. |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 542 | bool HasPEHeader = false; |
Eric Christopher | ee066fc | 2011-04-03 22:53:19 +0000 | [diff] [blame] | 543 | |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 544 | // Check if this is a PE/COFF file. |
Michael J. Spencer | ec29b12 | 2011-06-25 17:54:50 +0000 | [diff] [blame] | 545 | if (base()[0] == 0x4d && base()[1] == 0x5a) { |
Eric Christopher | ee066fc | 2011-04-03 22:53:19 +0000 | [diff] [blame] | 546 | // PE/COFF, seek through MS-DOS compatibility stub and 4-byte |
| 547 | // PE signature to find 'normal' COFF header. |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 548 | if (!checkSize(Data, EC, 0x3c + 8)) |
Rafael Espindola | c3f9b5a | 2014-06-23 21:53:12 +0000 | [diff] [blame] | 549 | return; |
Rui Ueyama | 82ebd8e | 2013-06-12 19:10:33 +0000 | [diff] [blame] | 550 | CurPtr = *reinterpret_cast<const ulittle16_t *>(base() + 0x3c); |
| 551 | // Check the PE magic bytes. ("PE\0\0") |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 552 | if (std::memcmp(base() + CurPtr, COFF::PEMagic, sizeof(COFF::PEMagic)) != |
| 553 | 0) { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 554 | EC = object_error::parse_failed; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 555 | return; |
| 556 | } |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 557 | CurPtr += sizeof(COFF::PEMagic); // Skip the PE magic bytes. |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 558 | HasPEHeader = true; |
Eric Christopher | ee066fc | 2011-04-03 22:53:19 +0000 | [diff] [blame] | 559 | } |
| 560 | |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 561 | if ((EC = getObject(COFFHeader, Data, base() + CurPtr))) |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 562 | return; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 563 | |
| 564 | // It might be a bigobj file, let's check. Note that COFF bigobj and COFF |
| 565 | // import libraries share a common prefix but bigobj is more restrictive. |
| 566 | if (!HasPEHeader && COFFHeader->Machine == COFF::IMAGE_FILE_MACHINE_UNKNOWN && |
| 567 | COFFHeader->NumberOfSections == uint16_t(0xffff) && |
| 568 | checkSize(Data, EC, sizeof(coff_bigobj_file_header))) { |
| 569 | if ((EC = getObject(COFFBigObjHeader, Data, base() + CurPtr))) |
| 570 | return; |
| 571 | |
| 572 | // Verify that we are dealing with bigobj. |
| 573 | if (COFFBigObjHeader->Version >= COFF::BigObjHeader::MinBigObjectVersion && |
| 574 | std::memcmp(COFFBigObjHeader->UUID, COFF::BigObjMagic, |
| 575 | sizeof(COFF::BigObjMagic)) == 0) { |
| 576 | COFFHeader = nullptr; |
| 577 | CurPtr += sizeof(coff_bigobj_file_header); |
| 578 | } else { |
| 579 | // It's not a bigobj. |
| 580 | COFFBigObjHeader = nullptr; |
| 581 | } |
| 582 | } |
| 583 | if (COFFHeader) { |
| 584 | // The prior checkSize call may have failed. This isn't a hard error |
| 585 | // because we were just trying to sniff out bigobj. |
| 586 | EC = object_error::success; |
| 587 | CurPtr += sizeof(coff_file_header); |
| 588 | |
| 589 | if (COFFHeader->isImportLibrary()) |
| 590 | return; |
| 591 | } |
Rui Ueyama | 82ebd8e | 2013-06-12 19:10:33 +0000 | [diff] [blame] | 592 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 593 | if (HasPEHeader) { |
Rui Ueyama | 10ed9dd | 2014-01-26 04:15:52 +0000 | [diff] [blame] | 594 | const pe32_header *Header; |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 595 | if ((EC = getObject(Header, Data, base() + CurPtr))) |
Rui Ueyama | 82ebd8e | 2013-06-12 19:10:33 +0000 | [diff] [blame] | 596 | return; |
Rui Ueyama | 10ed9dd | 2014-01-26 04:15:52 +0000 | [diff] [blame] | 597 | |
| 598 | const uint8_t *DataDirAddr; |
| 599 | uint64_t DataDirSize; |
| 600 | if (Header->Magic == 0x10b) { |
| 601 | PE32Header = Header; |
| 602 | DataDirAddr = base() + CurPtr + sizeof(pe32_header); |
| 603 | DataDirSize = sizeof(data_directory) * PE32Header->NumberOfRvaAndSize; |
| 604 | } else if (Header->Magic == 0x20b) { |
| 605 | PE32PlusHeader = reinterpret_cast<const pe32plus_header *>(Header); |
| 606 | DataDirAddr = base() + CurPtr + sizeof(pe32plus_header); |
| 607 | DataDirSize = sizeof(data_directory) * PE32PlusHeader->NumberOfRvaAndSize; |
| 608 | } else { |
| 609 | // It's neither PE32 nor PE32+. |
| 610 | EC = object_error::parse_failed; |
| 611 | return; |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 612 | } |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 613 | if ((EC = getObject(DataDirectory, Data, DataDirAddr, DataDirSize))) |
Rui Ueyama | 10ed9dd | 2014-01-26 04:15:52 +0000 | [diff] [blame] | 614 | return; |
Rui Ueyama | 82ebd8e | 2013-06-12 19:10:33 +0000 | [diff] [blame] | 615 | CurPtr += COFFHeader->SizeOfOptionalHeader; |
| 616 | } |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 617 | |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 618 | if ((EC = getObject(SectionTable, Data, base() + CurPtr, |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 619 | getNumberOfSections() * sizeof(coff_section)))) |
Rafael Espindola | 692410e | 2014-01-21 23:06:54 +0000 | [diff] [blame] | 620 | return; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 621 | |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 622 | // Initialize the pointer to the symbol table. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 623 | if (getPointerToSymbolTable() != 0) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 624 | if ((EC = initSymbolTablePtr())) |
Michael J. Spencer | d5930ca | 2011-11-08 23:34:07 +0000 | [diff] [blame] | 625 | return; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 626 | |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 627 | // Initialize the pointer to the beginning of the import table. |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 628 | if ((EC = initImportTablePtr())) |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 629 | return; |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 630 | if ((EC = initDelayImportTablePtr())) |
| 631 | return; |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 632 | |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 633 | // Initialize the pointer to the export table. |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 634 | if ((EC = initExportTablePtr())) |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 635 | return; |
| 636 | |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 637 | EC = object_error::success; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 638 | } |
| 639 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 640 | basic_symbol_iterator COFFObjectFile::symbol_begin_impl() const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 641 | DataRefImpl Ret; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 642 | Ret.p = getSymbolTable(); |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 643 | return basic_symbol_iterator(SymbolRef(Ret, this)); |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 644 | } |
| 645 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 646 | basic_symbol_iterator COFFObjectFile::symbol_end_impl() const { |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 647 | // The symbol table ends where the string table begins. |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 648 | DataRefImpl Ret; |
| 649 | Ret.p = reinterpret_cast<uintptr_t>(StringTable); |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 650 | return basic_symbol_iterator(SymbolRef(Ret, this)); |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 651 | } |
| 652 | |
Rui Ueyama | bc654b1 | 2013-09-27 21:47:05 +0000 | [diff] [blame] | 653 | import_directory_iterator COFFObjectFile::import_directory_begin() const { |
Rui Ueyama | a045b73 | 2014-01-16 03:13:19 +0000 | [diff] [blame] | 654 | return import_directory_iterator( |
| 655 | ImportDirectoryEntryRef(ImportDirectory, 0, this)); |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 656 | } |
| 657 | |
Rui Ueyama | bc654b1 | 2013-09-27 21:47:05 +0000 | [diff] [blame] | 658 | import_directory_iterator COFFObjectFile::import_directory_end() const { |
Rui Ueyama | a045b73 | 2014-01-16 03:13:19 +0000 | [diff] [blame] | 659 | return import_directory_iterator( |
| 660 | ImportDirectoryEntryRef(ImportDirectory, NumberOfImportDirectory, this)); |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 661 | } |
David Meyer | c429b80 | 2012-03-01 22:19:54 +0000 | [diff] [blame] | 662 | |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 663 | delay_import_directory_iterator |
| 664 | COFFObjectFile::delay_import_directory_begin() const { |
| 665 | return delay_import_directory_iterator( |
| 666 | DelayImportDirectoryEntryRef(DelayImportDirectory, 0, this)); |
| 667 | } |
| 668 | |
| 669 | delay_import_directory_iterator |
| 670 | COFFObjectFile::delay_import_directory_end() const { |
| 671 | return delay_import_directory_iterator( |
| 672 | DelayImportDirectoryEntryRef( |
| 673 | DelayImportDirectory, NumberOfDelayImportDirectory, this)); |
| 674 | } |
| 675 | |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 676 | export_directory_iterator COFFObjectFile::export_directory_begin() const { |
| 677 | return export_directory_iterator( |
| 678 | ExportDirectoryEntryRef(ExportDirectory, 0, this)); |
| 679 | } |
| 680 | |
| 681 | export_directory_iterator COFFObjectFile::export_directory_end() const { |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 682 | if (!ExportDirectory) |
| 683 | return export_directory_iterator(ExportDirectoryEntryRef(nullptr, 0, this)); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 684 | ExportDirectoryEntryRef Ref(ExportDirectory, |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 685 | ExportDirectory->AddressTableEntries, this); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 686 | return export_directory_iterator(Ref); |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 687 | } |
| 688 | |
Rafael Espindola | b5155a5 | 2014-02-10 20:24:04 +0000 | [diff] [blame] | 689 | section_iterator COFFObjectFile::section_begin() const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 690 | DataRefImpl Ret; |
| 691 | Ret.p = reinterpret_cast<uintptr_t>(SectionTable); |
| 692 | return section_iterator(SectionRef(Ret, this)); |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 693 | } |
| 694 | |
Rafael Espindola | b5155a5 | 2014-02-10 20:24:04 +0000 | [diff] [blame] | 695 | section_iterator COFFObjectFile::section_end() const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 696 | DataRefImpl Ret; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 697 | int NumSections = |
| 698 | COFFHeader && COFFHeader->isImportLibrary() ? 0 : getNumberOfSections(); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 699 | Ret.p = reinterpret_cast<uintptr_t>(SectionTable + NumSections); |
| 700 | return section_iterator(SectionRef(Ret, this)); |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 701 | } |
| 702 | |
| 703 | uint8_t COFFObjectFile::getBytesInAddress() const { |
Michael J. Spencer | 0324b67 | 2011-01-21 02:27:02 +0000 | [diff] [blame] | 704 | return getArch() == Triple::x86_64 ? 8 : 4; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 705 | } |
| 706 | |
| 707 | StringRef COFFObjectFile::getFileFormatName() const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 708 | switch(getMachine()) { |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 709 | case COFF::IMAGE_FILE_MACHINE_I386: |
| 710 | return "COFF-i386"; |
| 711 | case COFF::IMAGE_FILE_MACHINE_AMD64: |
| 712 | return "COFF-x86-64"; |
Saleem Abdulrasool | 9b7c0af | 2014-03-13 07:02:35 +0000 | [diff] [blame] | 713 | case COFF::IMAGE_FILE_MACHINE_ARMNT: |
| 714 | return "COFF-ARM"; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 715 | default: |
| 716 | return "COFF-<unknown arch>"; |
| 717 | } |
| 718 | } |
| 719 | |
| 720 | unsigned COFFObjectFile::getArch() const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 721 | switch (getMachine()) { |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 722 | case COFF::IMAGE_FILE_MACHINE_I386: |
| 723 | return Triple::x86; |
| 724 | case COFF::IMAGE_FILE_MACHINE_AMD64: |
| 725 | return Triple::x86_64; |
Saleem Abdulrasool | 9b7c0af | 2014-03-13 07:02:35 +0000 | [diff] [blame] | 726 | case COFF::IMAGE_FILE_MACHINE_ARMNT: |
| 727 | return Triple::thumb; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 728 | default: |
| 729 | return Triple::UnknownArch; |
| 730 | } |
| 731 | } |
| 732 | |
Rui Ueyama | 979fb40 | 2014-10-09 02:16:38 +0000 | [diff] [blame] | 733 | iterator_range<import_directory_iterator> |
| 734 | COFFObjectFile::import_directories() const { |
| 735 | return make_range(import_directory_begin(), import_directory_end()); |
| 736 | } |
| 737 | |
| 738 | iterator_range<delay_import_directory_iterator> |
| 739 | COFFObjectFile::delay_import_directories() const { |
| 740 | return make_range(delay_import_directory_begin(), |
| 741 | delay_import_directory_end()); |
| 742 | } |
| 743 | |
| 744 | iterator_range<export_directory_iterator> |
| 745 | COFFObjectFile::export_directories() const { |
| 746 | return make_range(export_directory_begin(), export_directory_end()); |
| 747 | } |
| 748 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 749 | std::error_code COFFObjectFile::getPE32Header(const pe32_header *&Res) const { |
Rui Ueyama | 82ebd8e | 2013-06-12 19:10:33 +0000 | [diff] [blame] | 750 | Res = PE32Header; |
Michael J. Spencer | 89a7a5e | 2011-10-17 23:53:56 +0000 | [diff] [blame] | 751 | return object_error::success; |
| 752 | } |
| 753 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 754 | std::error_code |
Rui Ueyama | 10ed9dd | 2014-01-26 04:15:52 +0000 | [diff] [blame] | 755 | COFFObjectFile::getPE32PlusHeader(const pe32plus_header *&Res) const { |
| 756 | Res = PE32PlusHeader; |
| 757 | return object_error::success; |
| 758 | } |
| 759 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 760 | std::error_code |
| 761 | COFFObjectFile::getDataDirectory(uint32_t Index, |
| 762 | const data_directory *&Res) const { |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 763 | // Error if if there's no data directory or the index is out of range. |
Rui Ueyama | 10ed9dd | 2014-01-26 04:15:52 +0000 | [diff] [blame] | 764 | if (!DataDirectory) |
| 765 | return object_error::parse_failed; |
| 766 | assert(PE32Header || PE32PlusHeader); |
| 767 | uint32_t NumEnt = PE32Header ? PE32Header->NumberOfRvaAndSize |
| 768 | : PE32PlusHeader->NumberOfRvaAndSize; |
| 769 | if (Index > NumEnt) |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 770 | return object_error::parse_failed; |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 771 | Res = &DataDirectory[Index]; |
Rui Ueyama | ed64342b | 2013-07-19 23:23:29 +0000 | [diff] [blame] | 772 | return object_error::success; |
| 773 | } |
| 774 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 775 | std::error_code COFFObjectFile::getSection(int32_t Index, |
| 776 | const coff_section *&Result) const { |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 777 | // Check for special index values. |
Rui Ueyama | f078eff | 2014-03-18 23:37:53 +0000 | [diff] [blame] | 778 | if (COFF::isReservedSectionNumber(Index)) |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 779 | Result = nullptr; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 780 | else if (Index > 0 && static_cast<uint32_t>(Index) <= getNumberOfSections()) |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 781 | // We already verified the section table data, so no need to check again. |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 782 | Result = SectionTable + (Index - 1); |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 783 | else |
| 784 | return object_error::parse_failed; |
| 785 | return object_error::success; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 786 | } |
| 787 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 788 | std::error_code COFFObjectFile::getString(uint32_t Offset, |
| 789 | StringRef &Result) const { |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 790 | if (StringTableSize <= 4) |
| 791 | // Tried to get a string from an empty string table. |
| 792 | return object_error::parse_failed; |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 793 | if (Offset >= StringTableSize) |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 794 | return object_error::unexpected_eof; |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 795 | Result = StringRef(StringTable + Offset); |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 796 | return object_error::success; |
Michael J. Spencer | 8e90ada | 2011-01-20 06:38:34 +0000 | [diff] [blame] | 797 | } |
| 798 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 799 | std::error_code COFFObjectFile::getSymbolName(COFFSymbolRef Symbol, |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 800 | StringRef &Res) const { |
Michael J. Spencer | 89a7a5e | 2011-10-17 23:53:56 +0000 | [diff] [blame] | 801 | // Check for string table entry. First 4 bytes are 0. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 802 | if (Symbol.getStringTableOffset().Zeroes == 0) { |
| 803 | uint32_t Offset = Symbol.getStringTableOffset().Offset; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 804 | if (std::error_code EC = getString(Offset, Res)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 805 | return EC; |
Michael J. Spencer | 89a7a5e | 2011-10-17 23:53:56 +0000 | [diff] [blame] | 806 | return object_error::success; |
| 807 | } |
| 808 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 809 | if (Symbol.getShortName()[COFF::NameSize - 1] == 0) |
Michael J. Spencer | 89a7a5e | 2011-10-17 23:53:56 +0000 | [diff] [blame] | 810 | // Null terminated, let ::strlen figure out the length. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 811 | Res = StringRef(Symbol.getShortName()); |
Michael J. Spencer | 89a7a5e | 2011-10-17 23:53:56 +0000 | [diff] [blame] | 812 | else |
| 813 | // Not null terminated, use all 8 bytes. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 814 | Res = StringRef(Symbol.getShortName(), COFF::NameSize); |
Michael J. Spencer | 89a7a5e | 2011-10-17 23:53:56 +0000 | [diff] [blame] | 815 | return object_error::success; |
| 816 | } |
| 817 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 818 | ArrayRef<uint8_t> |
| 819 | COFFObjectFile::getSymbolAuxData(COFFSymbolRef Symbol) const { |
Craig Topper | 2617dcc | 2014-04-15 06:32:26 +0000 | [diff] [blame] | 820 | const uint8_t *Aux = nullptr; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 821 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 822 | size_t SymbolSize = getSymbolTableEntrySize(); |
| 823 | if (Symbol.getNumberOfAuxSymbols() > 0) { |
| 824 | // AUX data comes immediately after the symbol in COFF |
| 825 | Aux = reinterpret_cast<const uint8_t *>(Symbol.getRawPtr()) + SymbolSize; |
Marshall Clow | 71757ef | 2012-06-15 01:08:25 +0000 | [diff] [blame] | 826 | # ifndef NDEBUG |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 827 | // Verify that the Aux symbol points to a valid entry in the symbol table. |
| 828 | uintptr_t Offset = uintptr_t(Aux) - uintptr_t(base()); |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 829 | if (Offset < getPointerToSymbolTable() || |
| 830 | Offset >= |
| 831 | getPointerToSymbolTable() + (getNumberOfSymbols() * SymbolSize)) |
Marshall Clow | 71757ef | 2012-06-15 01:08:25 +0000 | [diff] [blame] | 832 | report_fatal_error("Aux Symbol data was outside of symbol table."); |
| 833 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 834 | assert((Offset - getPointerToSymbolTable()) % SymbolSize == 0 && |
| 835 | "Aux Symbol data did not point to the beginning of a symbol"); |
Marshall Clow | 71757ef | 2012-06-15 01:08:25 +0000 | [diff] [blame] | 836 | # endif |
Marshall Clow | bfb85e6 | 2012-06-15 01:15:47 +0000 | [diff] [blame] | 837 | } |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 838 | return makeArrayRef(Aux, Symbol.getNumberOfAuxSymbols() * SymbolSize); |
Marshall Clow | 71757ef | 2012-06-15 01:08:25 +0000 | [diff] [blame] | 839 | } |
| 840 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 841 | std::error_code COFFObjectFile::getSectionName(const coff_section *Sec, |
| 842 | StringRef &Res) const { |
Michael J. Spencer | 53c2d54 | 2012-03-19 20:27:15 +0000 | [diff] [blame] | 843 | StringRef Name; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 844 | if (Sec->Name[COFF::NameSize - 1] == 0) |
Michael J. Spencer | 53c2d54 | 2012-03-19 20:27:15 +0000 | [diff] [blame] | 845 | // Null terminated, let ::strlen figure out the length. |
| 846 | Name = Sec->Name; |
| 847 | else |
| 848 | // Not null terminated, use all 8 bytes. |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 849 | Name = StringRef(Sec->Name, COFF::NameSize); |
Michael J. Spencer | 53c2d54 | 2012-03-19 20:27:15 +0000 | [diff] [blame] | 850 | |
| 851 | // Check for string table entry. First byte is '/'. |
| 852 | if (Name[0] == '/') { |
| 853 | uint32_t Offset; |
Nico Rieck | 9d2c15e | 2014-02-22 16:12:20 +0000 | [diff] [blame] | 854 | if (Name[1] == '/') { |
| 855 | if (decodeBase64StringEntry(Name.substr(2), Offset)) |
| 856 | return object_error::parse_failed; |
| 857 | } else { |
| 858 | if (Name.substr(1).getAsInteger(10, Offset)) |
| 859 | return object_error::parse_failed; |
| 860 | } |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 861 | if (std::error_code EC = getString(Offset, Name)) |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 862 | return EC; |
Michael J. Spencer | 53c2d54 | 2012-03-19 20:27:15 +0000 | [diff] [blame] | 863 | } |
| 864 | |
| 865 | Res = Name; |
| 866 | return object_error::success; |
| 867 | } |
| 868 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 869 | std::error_code |
| 870 | COFFObjectFile::getSectionContents(const coff_section *Sec, |
| 871 | ArrayRef<uint8_t> &Res) const { |
David Majnemer | dd9cff2 | 2014-10-09 07:49:28 +0000 | [diff] [blame^] | 872 | // PointerToRawData and SizeOfRawData won't make sense for BSS sections, |
| 873 | // don't do anything interesting for them. |
David Majnemer | dac3985 | 2014-09-26 22:32:16 +0000 | [diff] [blame] | 874 | assert((Sec->Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) == 0 && |
| 875 | "BSS sections don't have contents!"); |
Michael J. Spencer | 9da9e69 | 2012-03-19 20:27:37 +0000 | [diff] [blame] | 876 | // The only thing that we need to verify is that the contents is contained |
| 877 | // within the file bounds. We don't need to make sure it doesn't cover other |
| 878 | // data, as there's nothing that says that is not allowed. |
| 879 | uintptr_t ConStart = uintptr_t(base()) + Sec->PointerToRawData; |
David Majnemer | dd9cff2 | 2014-10-09 07:49:28 +0000 | [diff] [blame^] | 880 | // SizeOfRawData and VirtualSize change what they represent depending on |
| 881 | // whether or not we have an executable image. |
| 882 | // |
| 883 | // For object files, SizeOfRawData contains the size of section's data; |
| 884 | // VirtualSize is always zero. |
| 885 | // |
| 886 | // For executables, SizeOfRawData *must* be a multiple of FileAlignment; the |
| 887 | // actual section size is in VirtualSize. It is possible for VirtualSize to |
| 888 | // be greater than SizeOfRawData; the contents past that point should be |
| 889 | // considered to be zero. |
| 890 | uint32_t DataSize; |
| 891 | if (Sec->VirtualSize) |
| 892 | DataSize = std::min(Sec->VirtualSize, Sec->SizeOfRawData); |
| 893 | else |
| 894 | DataSize = Sec->SizeOfRawData; |
| 895 | uintptr_t ConEnd = ConStart + DataSize; |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 896 | if (ConEnd > uintptr_t(Data.getBufferEnd())) |
Michael J. Spencer | 9da9e69 | 2012-03-19 20:27:37 +0000 | [diff] [blame] | 897 | return object_error::parse_failed; |
David Majnemer | dd9cff2 | 2014-10-09 07:49:28 +0000 | [diff] [blame^] | 898 | Res = makeArrayRef(reinterpret_cast<const uint8_t *>(ConStart), DataSize); |
Michael J. Spencer | 9da9e69 | 2012-03-19 20:27:37 +0000 | [diff] [blame] | 899 | return object_error::success; |
| 900 | } |
| 901 | |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 902 | const coff_relocation *COFFObjectFile::toRel(DataRefImpl Rel) const { |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 903 | return reinterpret_cast<const coff_relocation*>(Rel.p); |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 904 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 905 | |
Rafael Espindola | 5e812af | 2014-01-30 02:49:50 +0000 | [diff] [blame] | 906 | void COFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const { |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 907 | Rel.p = reinterpret_cast<uintptr_t>( |
| 908 | reinterpret_cast<const coff_relocation*>(Rel.p) + 1); |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 909 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 910 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 911 | std::error_code COFFObjectFile::getRelocationAddress(DataRefImpl Rel, |
| 912 | uint64_t &Res) const { |
Rafael Espindola | 1e48387 | 2013-04-25 12:28:45 +0000 | [diff] [blame] | 913 | report_fatal_error("getRelocationAddress not implemented in COFFObjectFile"); |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 914 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 915 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 916 | std::error_code COFFObjectFile::getRelocationOffset(DataRefImpl Rel, |
| 917 | uint64_t &Res) const { |
Danil Malyshev | cbe72fc | 2011-11-29 17:40:10 +0000 | [diff] [blame] | 918 | Res = toRel(Rel)->VirtualAddress; |
| 919 | return object_error::success; |
| 920 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 921 | |
Rafael Espindola | 806f006 | 2013-06-05 01:33:53 +0000 | [diff] [blame] | 922 | symbol_iterator COFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const { |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 923 | const coff_relocation *R = toRel(Rel); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 924 | DataRefImpl Ref; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 925 | if (SymbolTable16) |
| 926 | Ref.p = reinterpret_cast<uintptr_t>(SymbolTable16 + R->SymbolTableIndex); |
| 927 | else if (SymbolTable32) |
| 928 | Ref.p = reinterpret_cast<uintptr_t>(SymbolTable32 + R->SymbolTableIndex); |
| 929 | else |
| 930 | llvm_unreachable("no symbol table pointer!"); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 931 | return symbol_iterator(SymbolRef(Ref, this)); |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 932 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 933 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 934 | std::error_code COFFObjectFile::getRelocationType(DataRefImpl Rel, |
| 935 | uint64_t &Res) const { |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 936 | const coff_relocation* R = toRel(Rel); |
| 937 | Res = R->Type; |
| 938 | return object_error::success; |
| 939 | } |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 940 | |
Alexey Samsonov | 27dc839 | 2014-03-18 06:53:02 +0000 | [diff] [blame] | 941 | const coff_section * |
| 942 | COFFObjectFile::getCOFFSection(const SectionRef &Section) const { |
| 943 | return toSec(Section.getRawDataRefImpl()); |
Marshall Clow | 71757ef | 2012-06-15 01:08:25 +0000 | [diff] [blame] | 944 | } |
| 945 | |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 946 | COFFSymbolRef COFFObjectFile::getCOFFSymbol(const DataRefImpl &Ref) const { |
| 947 | if (SymbolTable16) |
| 948 | return toSymb<coff_symbol16>(Ref); |
| 949 | if (SymbolTable32) |
| 950 | return toSymb<coff_symbol32>(Ref); |
| 951 | llvm_unreachable("no symbol table pointer!"); |
| 952 | } |
| 953 | |
| 954 | COFFSymbolRef COFFObjectFile::getCOFFSymbol(const SymbolRef &Symbol) const { |
| 955 | return getCOFFSymbol(Symbol.getRawDataRefImpl()); |
Marshall Clow | 71757ef | 2012-06-15 01:08:25 +0000 | [diff] [blame] | 956 | } |
| 957 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 958 | const coff_relocation * |
Alexey Samsonov | 27dc839 | 2014-03-18 06:53:02 +0000 | [diff] [blame] | 959 | COFFObjectFile::getCOFFRelocation(const RelocationRef &Reloc) const { |
| 960 | return toRel(Reloc.getRawDataRefImpl()); |
Marshall Clow | d3e2a76 | 2012-06-18 19:47:16 +0000 | [diff] [blame] | 961 | } |
| 962 | |
Alexey Samsonov | 27dc839 | 2014-03-18 06:53:02 +0000 | [diff] [blame] | 963 | #define LLVM_COFF_SWITCH_RELOC_TYPE_NAME(reloc_type) \ |
| 964 | case COFF::reloc_type: \ |
| 965 | Res = #reloc_type; \ |
| 966 | break; |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 967 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 968 | std::error_code |
| 969 | COFFObjectFile::getRelocationTypeName(DataRefImpl Rel, |
| 970 | SmallVectorImpl<char> &Result) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 971 | const coff_relocation *Reloc = toRel(Rel); |
| 972 | StringRef Res; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 973 | switch (getMachine()) { |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 974 | case COFF::IMAGE_FILE_MACHINE_AMD64: |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 975 | switch (Reloc->Type) { |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 976 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ABSOLUTE); |
| 977 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR64); |
| 978 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32); |
| 979 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_ADDR32NB); |
| 980 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32); |
| 981 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_1); |
| 982 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_2); |
| 983 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_3); |
| 984 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_4); |
| 985 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_REL32_5); |
| 986 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECTION); |
| 987 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL); |
| 988 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SECREL7); |
| 989 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_TOKEN); |
| 990 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SREL32); |
| 991 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_PAIR); |
| 992 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_AMD64_SSPAN32); |
| 993 | default: |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 994 | Res = "Unknown"; |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 995 | } |
| 996 | break; |
Saleem Abdulrasool | 5c503bf | 2014-04-09 06:18:28 +0000 | [diff] [blame] | 997 | case COFF::IMAGE_FILE_MACHINE_ARMNT: |
| 998 | switch (Reloc->Type) { |
| 999 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ABSOLUTE); |
| 1000 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ADDR32); |
| 1001 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_ADDR32NB); |
| 1002 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH24); |
| 1003 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH11); |
| 1004 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_TOKEN); |
| 1005 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX24); |
| 1006 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX11); |
| 1007 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_SECTION); |
| 1008 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_SECREL); |
| 1009 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_MOV32A); |
| 1010 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_MOV32T); |
| 1011 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH20T); |
| 1012 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BRANCH24T); |
| 1013 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_ARM_BLX23T); |
| 1014 | default: |
| 1015 | Res = "Unknown"; |
| 1016 | } |
| 1017 | break; |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 1018 | case COFF::IMAGE_FILE_MACHINE_I386: |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1019 | switch (Reloc->Type) { |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 1020 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_ABSOLUTE); |
| 1021 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR16); |
| 1022 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL16); |
| 1023 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32); |
| 1024 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_DIR32NB); |
| 1025 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SEG12); |
| 1026 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECTION); |
| 1027 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL); |
| 1028 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_TOKEN); |
| 1029 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_SECREL7); |
| 1030 | LLVM_COFF_SWITCH_RELOC_TYPE_NAME(IMAGE_REL_I386_REL32); |
| 1031 | default: |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1032 | Res = "Unknown"; |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 1033 | } |
| 1034 | break; |
| 1035 | default: |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1036 | Res = "Unknown"; |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 1037 | } |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1038 | Result.append(Res.begin(), Res.end()); |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 1039 | return object_error::success; |
| 1040 | } |
| 1041 | |
| 1042 | #undef LLVM_COFF_SWITCH_RELOC_TYPE_NAME |
| 1043 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1044 | std::error_code |
| 1045 | COFFObjectFile::getRelocationValueString(DataRefImpl Rel, |
| 1046 | SmallVectorImpl<char> &Result) const { |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1047 | const coff_relocation *Reloc = toRel(Rel); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1048 | DataRefImpl Sym; |
David Majnemer | 44f51e5 | 2014-09-10 12:51:52 +0000 | [diff] [blame] | 1049 | ErrorOr<COFFSymbolRef> Symb = getSymbol(Reloc->SymbolTableIndex); |
| 1050 | if (std::error_code EC = Symb.getError()) |
| 1051 | return EC; |
| 1052 | Sym.p = reinterpret_cast<uintptr_t>(Symb->getRawPtr()); |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1053 | StringRef SymName; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1054 | if (std::error_code EC = getSymbolName(Sym, SymName)) |
| 1055 | return EC; |
Rui Ueyama | 8ff24d2 | 2014-01-16 20:11:48 +0000 | [diff] [blame] | 1056 | Result.append(SymName.begin(), SymName.end()); |
Michael J. Spencer | e5fd004 | 2011-10-07 19:25:32 +0000 | [diff] [blame] | 1057 | return object_error::success; |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 1058 | } |
Benjamin Kramer | 022ecdf | 2011-09-08 20:52:17 +0000 | [diff] [blame] | 1059 | |
Rafael Espindola | c66d761 | 2014-08-17 19:09:37 +0000 | [diff] [blame] | 1060 | bool COFFObjectFile::isRelocatableObject() const { |
| 1061 | return !DataDirectory; |
| 1062 | } |
| 1063 | |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1064 | bool ImportDirectoryEntryRef:: |
| 1065 | operator==(const ImportDirectoryEntryRef &Other) const { |
Rui Ueyama | a045b73 | 2014-01-16 03:13:19 +0000 | [diff] [blame] | 1066 | return ImportTable == Other.ImportTable && Index == Other.Index; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1067 | } |
| 1068 | |
Rafael Espindola | 5e812af | 2014-01-30 02:49:50 +0000 | [diff] [blame] | 1069 | void ImportDirectoryEntryRef::moveNext() { |
| 1070 | ++Index; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1071 | } |
| 1072 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1073 | std::error_code ImportDirectoryEntryRef::getImportTableEntry( |
| 1074 | const import_directory_table_entry *&Result) const { |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 1075 | Result = ImportTable + Index; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1076 | return object_error::success; |
| 1077 | } |
| 1078 | |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1079 | static imported_symbol_iterator |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1080 | makeImportedSymbolIterator(const COFFObjectFile *Object, |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1081 | uintptr_t Ptr, int Index) { |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1082 | if (Object->getBytesInAddress() == 4) { |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1083 | auto *P = reinterpret_cast<const import_lookup_table_entry32 *>(Ptr); |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1084 | return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object)); |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1085 | } |
| 1086 | auto *P = reinterpret_cast<const import_lookup_table_entry64 *>(Ptr); |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1087 | return imported_symbol_iterator(ImportedSymbolRef(P, Index, Object)); |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1088 | } |
| 1089 | |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1090 | static imported_symbol_iterator |
| 1091 | importedSymbolBegin(uint32_t RVA, const COFFObjectFile *Object) { |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1092 | uintptr_t IntPtr = 0; |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1093 | Object->getRvaPtr(RVA, IntPtr); |
| 1094 | return makeImportedSymbolIterator(Object, IntPtr, 0); |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1095 | } |
| 1096 | |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1097 | static imported_symbol_iterator |
| 1098 | importedSymbolEnd(uint32_t RVA, const COFFObjectFile *Object) { |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1099 | uintptr_t IntPtr = 0; |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1100 | Object->getRvaPtr(RVA, IntPtr); |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1101 | // Forward the pointer to the last entry which is null. |
| 1102 | int Index = 0; |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1103 | if (Object->getBytesInAddress() == 4) { |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1104 | auto *Entry = reinterpret_cast<ulittle32_t *>(IntPtr); |
| 1105 | while (*Entry++) |
| 1106 | ++Index; |
| 1107 | } else { |
| 1108 | auto *Entry = reinterpret_cast<ulittle64_t *>(IntPtr); |
| 1109 | while (*Entry++) |
| 1110 | ++Index; |
| 1111 | } |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1112 | return makeImportedSymbolIterator(Object, IntPtr, Index); |
| 1113 | } |
| 1114 | |
| 1115 | imported_symbol_iterator |
| 1116 | ImportDirectoryEntryRef::imported_symbol_begin() const { |
| 1117 | return importedSymbolBegin(ImportTable[Index].ImportLookupTableRVA, |
| 1118 | OwningObject); |
| 1119 | } |
| 1120 | |
| 1121 | imported_symbol_iterator |
| 1122 | ImportDirectoryEntryRef::imported_symbol_end() const { |
| 1123 | return importedSymbolEnd(ImportTable[Index].ImportLookupTableRVA, |
| 1124 | OwningObject); |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1125 | } |
| 1126 | |
Rui Ueyama | 979fb40 | 2014-10-09 02:16:38 +0000 | [diff] [blame] | 1127 | iterator_range<imported_symbol_iterator> |
| 1128 | ImportDirectoryEntryRef::imported_symbols() const { |
| 1129 | return make_range(imported_symbol_begin(), imported_symbol_end()); |
| 1130 | } |
| 1131 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1132 | std::error_code ImportDirectoryEntryRef::getName(StringRef &Result) const { |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1133 | uintptr_t IntPtr = 0; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1134 | if (std::error_code EC = |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 1135 | OwningObject->getRvaPtr(ImportTable[Index].NameRVA, IntPtr)) |
Rui Ueyama | a045b73 | 2014-01-16 03:13:19 +0000 | [diff] [blame] | 1136 | return EC; |
| 1137 | Result = StringRef(reinterpret_cast<const char *>(IntPtr)); |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1138 | return object_error::success; |
| 1139 | } |
| 1140 | |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 1141 | std::error_code |
| 1142 | ImportDirectoryEntryRef::getImportLookupTableRVA(uint32_t &Result) const { |
| 1143 | Result = ImportTable[Index].ImportLookupTableRVA; |
| 1144 | return object_error::success; |
| 1145 | } |
| 1146 | |
| 1147 | std::error_code |
| 1148 | ImportDirectoryEntryRef::getImportAddressTableRVA(uint32_t &Result) const { |
| 1149 | Result = ImportTable[Index].ImportAddressTableRVA; |
| 1150 | return object_error::success; |
| 1151 | } |
| 1152 | |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1153 | std::error_code ImportDirectoryEntryRef::getImportLookupEntry( |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1154 | const import_lookup_table_entry32 *&Result) const { |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1155 | uintptr_t IntPtr = 0; |
Rui Ueyama | 1e152d5 | 2014-10-02 17:02:18 +0000 | [diff] [blame] | 1156 | uint32_t RVA = ImportTable[Index].ImportLookupTableRVA; |
| 1157 | if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr)) |
Rui Ueyama | a045b73 | 2014-01-16 03:13:19 +0000 | [diff] [blame] | 1158 | return EC; |
Rui Ueyama | c2bed42 | 2013-09-27 21:04:00 +0000 | [diff] [blame] | 1159 | Result = reinterpret_cast<const import_lookup_table_entry32 *>(IntPtr); |
| 1160 | return object_error::success; |
| 1161 | } |
| 1162 | |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1163 | bool DelayImportDirectoryEntryRef:: |
| 1164 | operator==(const DelayImportDirectoryEntryRef &Other) const { |
| 1165 | return Table == Other.Table && Index == Other.Index; |
| 1166 | } |
| 1167 | |
| 1168 | void DelayImportDirectoryEntryRef::moveNext() { |
| 1169 | ++Index; |
| 1170 | } |
| 1171 | |
| 1172 | imported_symbol_iterator |
| 1173 | DelayImportDirectoryEntryRef::imported_symbol_begin() const { |
| 1174 | return importedSymbolBegin(Table[Index].DelayImportNameTable, |
| 1175 | OwningObject); |
| 1176 | } |
| 1177 | |
| 1178 | imported_symbol_iterator |
| 1179 | DelayImportDirectoryEntryRef::imported_symbol_end() const { |
| 1180 | return importedSymbolEnd(Table[Index].DelayImportNameTable, |
| 1181 | OwningObject); |
| 1182 | } |
| 1183 | |
Rui Ueyama | 979fb40 | 2014-10-09 02:16:38 +0000 | [diff] [blame] | 1184 | iterator_range<imported_symbol_iterator> |
| 1185 | DelayImportDirectoryEntryRef::imported_symbols() const { |
| 1186 | return make_range(imported_symbol_begin(), imported_symbol_end()); |
| 1187 | } |
| 1188 | |
Rui Ueyama | 15d9935 | 2014-10-03 00:41:58 +0000 | [diff] [blame] | 1189 | std::error_code DelayImportDirectoryEntryRef::getName(StringRef &Result) const { |
| 1190 | uintptr_t IntPtr = 0; |
| 1191 | if (std::error_code EC = OwningObject->getRvaPtr(Table[Index].Name, IntPtr)) |
| 1192 | return EC; |
| 1193 | Result = StringRef(reinterpret_cast<const char *>(IntPtr)); |
| 1194 | return object_error::success; |
| 1195 | } |
| 1196 | |
Rui Ueyama | 1af0865 | 2014-10-03 18:07:18 +0000 | [diff] [blame] | 1197 | std::error_code DelayImportDirectoryEntryRef:: |
| 1198 | getDelayImportTable(const delay_import_directory_table_entry *&Result) const { |
| 1199 | Result = Table; |
| 1200 | return object_error::success; |
| 1201 | } |
| 1202 | |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1203 | bool ExportDirectoryEntryRef:: |
| 1204 | operator==(const ExportDirectoryEntryRef &Other) const { |
| 1205 | return ExportTable == Other.ExportTable && Index == Other.Index; |
| 1206 | } |
| 1207 | |
Rafael Espindola | 5e812af | 2014-01-30 02:49:50 +0000 | [diff] [blame] | 1208 | void ExportDirectoryEntryRef::moveNext() { |
| 1209 | ++Index; |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1210 | } |
| 1211 | |
Rui Ueyama | da49d0d | 2014-01-16 20:50:34 +0000 | [diff] [blame] | 1212 | // Returns the name of the current export symbol. If the symbol is exported only |
| 1213 | // by ordinal, the empty string is set as a result. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1214 | std::error_code ExportDirectoryEntryRef::getDllName(StringRef &Result) const { |
Rui Ueyama | da49d0d | 2014-01-16 20:50:34 +0000 | [diff] [blame] | 1215 | uintptr_t IntPtr = 0; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1216 | if (std::error_code EC = |
| 1217 | OwningObject->getRvaPtr(ExportTable->NameRVA, IntPtr)) |
Rui Ueyama | da49d0d | 2014-01-16 20:50:34 +0000 | [diff] [blame] | 1218 | return EC; |
| 1219 | Result = StringRef(reinterpret_cast<const char *>(IntPtr)); |
| 1220 | return object_error::success; |
| 1221 | } |
| 1222 | |
Rui Ueyama | e5df609 | 2014-01-17 22:02:24 +0000 | [diff] [blame] | 1223 | // Returns the starting ordinal number. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1224 | std::error_code |
| 1225 | ExportDirectoryEntryRef::getOrdinalBase(uint32_t &Result) const { |
Rui Ueyama | e5df609 | 2014-01-17 22:02:24 +0000 | [diff] [blame] | 1226 | Result = ExportTable->OrdinalBase; |
| 1227 | return object_error::success; |
| 1228 | } |
| 1229 | |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1230 | // Returns the export ordinal of the current export symbol. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1231 | std::error_code ExportDirectoryEntryRef::getOrdinal(uint32_t &Result) const { |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1232 | Result = ExportTable->OrdinalBase + Index; |
| 1233 | return object_error::success; |
| 1234 | } |
| 1235 | |
| 1236 | // Returns the address of the current export symbol. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1237 | std::error_code ExportDirectoryEntryRef::getExportRVA(uint32_t &Result) const { |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1238 | uintptr_t IntPtr = 0; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1239 | if (std::error_code EC = |
| 1240 | OwningObject->getRvaPtr(ExportTable->ExportAddressTableRVA, IntPtr)) |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1241 | return EC; |
Rui Ueyama | 24fc2d6 | 2014-01-17 22:11:27 +0000 | [diff] [blame] | 1242 | const export_address_table_entry *entry = |
| 1243 | reinterpret_cast<const export_address_table_entry *>(IntPtr); |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1244 | Result = entry[Index].ExportRVA; |
| 1245 | return object_error::success; |
| 1246 | } |
| 1247 | |
| 1248 | // Returns the name of the current export symbol. If the symbol is exported only |
| 1249 | // by ordinal, the empty string is set as a result. |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1250 | std::error_code |
| 1251 | ExportDirectoryEntryRef::getSymbolName(StringRef &Result) const { |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1252 | uintptr_t IntPtr = 0; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1253 | if (std::error_code EC = |
| 1254 | OwningObject->getRvaPtr(ExportTable->OrdinalTableRVA, IntPtr)) |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1255 | return EC; |
| 1256 | const ulittle16_t *Start = reinterpret_cast<const ulittle16_t *>(IntPtr); |
| 1257 | |
| 1258 | uint32_t NumEntries = ExportTable->NumberOfNamePointers; |
| 1259 | int Offset = 0; |
| 1260 | for (const ulittle16_t *I = Start, *E = Start + NumEntries; |
| 1261 | I < E; ++I, ++Offset) { |
| 1262 | if (*I != Index) |
| 1263 | continue; |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1264 | if (std::error_code EC = |
| 1265 | OwningObject->getRvaPtr(ExportTable->NamePointerRVA, IntPtr)) |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1266 | return EC; |
| 1267 | const ulittle32_t *NamePtr = reinterpret_cast<const ulittle32_t *>(IntPtr); |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1268 | if (std::error_code EC = OwningObject->getRvaPtr(NamePtr[Offset], IntPtr)) |
Rui Ueyama | ad882ba | 2014-01-16 07:05:49 +0000 | [diff] [blame] | 1269 | return EC; |
| 1270 | Result = StringRef(reinterpret_cast<const char *>(IntPtr)); |
| 1271 | return object_error::success; |
| 1272 | } |
| 1273 | Result = ""; |
| 1274 | return object_error::success; |
| 1275 | } |
| 1276 | |
Rui Ueyama | 861021f | 2014-10-02 22:05:29 +0000 | [diff] [blame] | 1277 | bool ImportedSymbolRef:: |
| 1278 | operator==(const ImportedSymbolRef &Other) const { |
| 1279 | return Entry32 == Other.Entry32 && Entry64 == Other.Entry64 |
| 1280 | && Index == Other.Index; |
| 1281 | } |
| 1282 | |
| 1283 | void ImportedSymbolRef::moveNext() { |
| 1284 | ++Index; |
| 1285 | } |
| 1286 | |
| 1287 | std::error_code |
| 1288 | ImportedSymbolRef::getSymbolName(StringRef &Result) const { |
| 1289 | uint32_t RVA; |
| 1290 | if (Entry32) { |
| 1291 | // If a symbol is imported only by ordinal, it has no name. |
| 1292 | if (Entry32[Index].isOrdinal()) |
| 1293 | return object_error::success; |
| 1294 | RVA = Entry32[Index].getHintNameRVA(); |
| 1295 | } else { |
| 1296 | if (Entry64[Index].isOrdinal()) |
| 1297 | return object_error::success; |
| 1298 | RVA = Entry64[Index].getHintNameRVA(); |
| 1299 | } |
| 1300 | uintptr_t IntPtr = 0; |
| 1301 | if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr)) |
| 1302 | return EC; |
| 1303 | // +2 because the first two bytes is hint. |
| 1304 | Result = StringRef(reinterpret_cast<const char *>(IntPtr + 2)); |
| 1305 | return object_error::success; |
| 1306 | } |
| 1307 | |
| 1308 | std::error_code ImportedSymbolRef::getOrdinal(uint16_t &Result) const { |
| 1309 | uint32_t RVA; |
| 1310 | if (Entry32) { |
| 1311 | if (Entry32[Index].isOrdinal()) { |
| 1312 | Result = Entry32[Index].getOrdinal(); |
| 1313 | return object_error::success; |
| 1314 | } |
| 1315 | RVA = Entry32[Index].getHintNameRVA(); |
| 1316 | } else { |
| 1317 | if (Entry64[Index].isOrdinal()) { |
| 1318 | Result = Entry64[Index].getOrdinal(); |
| 1319 | return object_error::success; |
| 1320 | } |
| 1321 | RVA = Entry64[Index].getHintNameRVA(); |
| 1322 | } |
| 1323 | uintptr_t IntPtr = 0; |
| 1324 | if (std::error_code EC = OwningObject->getRvaPtr(RVA, IntPtr)) |
| 1325 | return EC; |
| 1326 | Result = *reinterpret_cast<const ulittle16_t *>(IntPtr); |
| 1327 | return object_error::success; |
| 1328 | } |
| 1329 | |
Rafael Espindola | 437b0d5 | 2014-07-31 03:12:45 +0000 | [diff] [blame] | 1330 | ErrorOr<std::unique_ptr<COFFObjectFile>> |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 1331 | ObjectFile::createCOFFObjectFile(MemoryBufferRef Object) { |
Rafael Espindola | db4ed0b | 2014-06-13 02:24:39 +0000 | [diff] [blame] | 1332 | std::error_code EC; |
Rafael Espindola | 48af1c2 | 2014-08-19 18:44:46 +0000 | [diff] [blame] | 1333 | std::unique_ptr<COFFObjectFile> Ret(new COFFObjectFile(Object, EC)); |
Rafael Espindola | 692410e | 2014-01-21 23:06:54 +0000 | [diff] [blame] | 1334 | if (EC) |
| 1335 | return EC; |
Rafael Espindola | 437b0d5 | 2014-07-31 03:12:45 +0000 | [diff] [blame] | 1336 | return std::move(Ret); |
Rui Ueyama | 686738e | 2014-01-16 20:30:36 +0000 | [diff] [blame] | 1337 | } |