1 //===- ELFObjHandler.cpp --------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===-----------------------------------------------------------------------===/
8
9 #include "llvm/InterfaceStub/ELFObjHandler.h"
10 #include "llvm/InterfaceStub/ELFStub.h"
11 #include "llvm/MC/StringTableBuilder.h"
12 #include "llvm/Object/Binary.h"
13 #include "llvm/Object/ELFObjectFile.h"
14 #include "llvm/Object/ELFTypes.h"
15 #include "llvm/Support/Errc.h"
16 #include "llvm/Support/Error.h"
17 #include "llvm/Support/FileOutputBuffer.h"
18 #include "llvm/Support/MathExtras.h"
19 #include "llvm/Support/MemoryBuffer.h"
20 #include "llvm/Support/Process.h"
21
22 using llvm::MemoryBufferRef;
23 using llvm::object::ELFObjectFile;
24
25 using namespace llvm;
26 using namespace llvm::object;
27 using namespace llvm::ELF;
28
29 namespace llvm {
30 namespace elfabi {
31
32 // Simple struct to hold relevant .dynamic entries.
33 struct DynamicEntries {
34 uint64_t StrTabAddr = 0;
35 uint64_t StrSize = 0;
36 Optional<uint64_t> SONameOffset;
37 std::vector<uint64_t> NeededLibNames;
38 // Symbol table:
39 uint64_t DynSymAddr = 0;
40 // Hash tables:
41 Optional<uint64_t> ElfHash;
42 Optional<uint64_t> GnuHash;
43 };
44
45 /// This initializes an ELF file header with information specific to a binary
46 /// dynamic shared object.
47 /// Offsets, indexes, links, etc. for section and program headers are just
48 /// zero-initialized as they will be updated elsewhere.
49 ///
50 /// @param ElfHeader Target ELFT::Ehdr to populate.
51 /// @param Machine Target architecture (e_machine from ELF specifications).
52 template <class ELFT>
initELFHeader(typename ELFT::Ehdr & ElfHeader,uint16_t Machine)53 static void initELFHeader(typename ELFT::Ehdr &ElfHeader, uint16_t Machine) {
54 memset(&ElfHeader, 0, sizeof(ElfHeader));
55 // ELF identification.
56 ElfHeader.e_ident[EI_MAG0] = ElfMagic[EI_MAG0];
57 ElfHeader.e_ident[EI_MAG1] = ElfMagic[EI_MAG1];
58 ElfHeader.e_ident[EI_MAG2] = ElfMagic[EI_MAG2];
59 ElfHeader.e_ident[EI_MAG3] = ElfMagic[EI_MAG3];
60 ElfHeader.e_ident[EI_CLASS] = ELFT::Is64Bits ? ELFCLASS64 : ELFCLASS32;
61 bool IsLittleEndian = ELFT::TargetEndianness == support::little;
62 ElfHeader.e_ident[EI_DATA] = IsLittleEndian ? ELFDATA2LSB : ELFDATA2MSB;
63 ElfHeader.e_ident[EI_VERSION] = EV_CURRENT;
64 ElfHeader.e_ident[EI_OSABI] = ELFOSABI_NONE;
65
66 // Remainder of ELF header.
67 ElfHeader.e_type = ET_DYN;
68 ElfHeader.e_machine = Machine;
69 ElfHeader.e_version = EV_CURRENT;
70 ElfHeader.e_ehsize = sizeof(typename ELFT::Ehdr);
71 ElfHeader.e_phentsize = sizeof(typename ELFT::Phdr);
72 ElfHeader.e_shentsize = sizeof(typename ELFT::Shdr);
73 }
74
75 namespace {
76 template <class ELFT> struct OutputSection {
77 using Elf_Shdr = typename ELFT::Shdr;
78 std::string Name;
79 Elf_Shdr Shdr;
80 uint64_t Addr;
81 uint64_t Offset;
82 uint64_t Size;
83 uint64_t Align;
84 uint32_t Index;
85 bool NoBits = true;
86 };
87
88 template <class T, class ELFT>
89 struct ContentSection : public OutputSection<ELFT> {
90 T Content;
ContentSectionllvm::elfabi::__anon88d330090111::ContentSection91 ContentSection() { this->NoBits = false; }
92 };
93
94 // This class just wraps StringTableBuilder for the purpose of adding a
95 // default constructor.
96 class ELFStringTableBuilder : public StringTableBuilder {
97 public:
ELFStringTableBuilder()98 ELFStringTableBuilder() : StringTableBuilder(StringTableBuilder::ELF) {}
99 };
100
101 template <class ELFT> class ELFSymbolTableBuilder {
102 public:
103 using Elf_Sym = typename ELFT::Sym;
104
ELFSymbolTableBuilder()105 ELFSymbolTableBuilder() { Symbols.push_back({}); }
106
add(size_t StNameOffset,uint64_t StSize,uint8_t StBind,uint8_t StType,uint8_t StOther,uint16_t StShndx)107 void add(size_t StNameOffset, uint64_t StSize, uint8_t StBind, uint8_t StType,
108 uint8_t StOther, uint16_t StShndx) {
109 Elf_Sym S{};
110 S.st_name = StNameOffset;
111 S.st_size = StSize;
112 S.st_info = (StBind << 4) | (StType & 0xf);
113 S.st_other = StOther;
114 S.st_shndx = StShndx;
115 Symbols.push_back(S);
116 }
117
getSize() const118 size_t getSize() const { return Symbols.size() * sizeof(Elf_Sym); }
119
write(uint8_t * Buf) const120 void write(uint8_t *Buf) const {
121 memcpy(Buf, Symbols.data(), sizeof(Elf_Sym) * Symbols.size());
122 }
123
124 private:
125 llvm::SmallVector<Elf_Sym, 8> Symbols;
126 };
127
128 template <class ELFT> class ELFDynamicTableBuilder {
129 public:
130 using Elf_Dyn = typename ELFT::Dyn;
131
addAddr(uint64_t Tag,uint64_t Addr)132 size_t addAddr(uint64_t Tag, uint64_t Addr) {
133 Elf_Dyn Entry;
134 Entry.d_tag = Tag;
135 Entry.d_un.d_ptr = Addr;
136 Entries.push_back(Entry);
137 return Entries.size() - 1;
138 }
139
modifyAddr(size_t Index,uint64_t Addr)140 void modifyAddr(size_t Index, uint64_t Addr) {
141 Entries[Index].d_un.d_ptr = Addr;
142 }
143
addValue(uint64_t Tag,uint64_t Value)144 size_t addValue(uint64_t Tag, uint64_t Value) {
145 Elf_Dyn Entry;
146 Entry.d_tag = Tag;
147 Entry.d_un.d_val = Value;
148 Entries.push_back(Entry);
149 return Entries.size() - 1;
150 }
151
modifyValue(size_t Index,uint64_t Value)152 void modifyValue(size_t Index, uint64_t Value) {
153 Entries[Index].d_un.d_val = Value;
154 }
155
getSize() const156 size_t getSize() const {
157 // Add DT_NULL entry at the end.
158 return (Entries.size() + 1) * sizeof(Elf_Dyn);
159 }
160
write(uint8_t * Buf) const161 void write(uint8_t *Buf) const {
162 memcpy(Buf, Entries.data(), sizeof(Elf_Dyn) * Entries.size());
163 // Add DT_NULL entry at the end.
164 memset(Buf + sizeof(Elf_Dyn) * Entries.size(), 0, sizeof(Elf_Dyn));
165 }
166
167 private:
168 llvm::SmallVector<Elf_Dyn, 8> Entries;
169 };
170
171 template <class ELFT> class ELFStubBuilder {
172 public:
173 using Elf_Ehdr = typename ELFT::Ehdr;
174 using Elf_Shdr = typename ELFT::Shdr;
175 using Elf_Phdr = typename ELFT::Phdr;
176 using Elf_Sym = typename ELFT::Sym;
177 using Elf_Addr = typename ELFT::Addr;
178 using Elf_Dyn = typename ELFT::Dyn;
179
180 ELFStubBuilder(const ELFStubBuilder &) = delete;
181 ELFStubBuilder(ELFStubBuilder &&) = default;
182
ELFStubBuilder(const ELFStub & Stub)183 explicit ELFStubBuilder(const ELFStub &Stub) {
184 DynSym.Name = ".dynsym";
185 DynSym.Align = sizeof(Elf_Addr);
186 DynStr.Name = ".dynstr";
187 DynStr.Align = 1;
188 DynTab.Name = ".dynamic";
189 DynTab.Align = sizeof(Elf_Addr);
190 ShStrTab.Name = ".shstrtab";
191 ShStrTab.Align = 1;
192
193 // Populate string tables.
194 for (const ELFSymbol &Sym : Stub.Symbols)
195 DynStr.Content.add(Sym.Name);
196 for (const std::string &Lib : Stub.NeededLibs)
197 DynStr.Content.add(Lib);
198 if (Stub.SoName)
199 DynStr.Content.add(Stub.SoName.getValue());
200
201 std::vector<OutputSection<ELFT> *> Sections = {&DynSym, &DynStr, &DynTab,
202 &ShStrTab};
203 const OutputSection<ELFT> *LastSection = Sections.back();
204 // Now set the Index and put sections names into ".shstrtab".
205 uint64_t Index = 1;
206 for (OutputSection<ELFT> *Sec : Sections) {
207 Sec->Index = Index++;
208 ShStrTab.Content.add(Sec->Name);
209 }
210 ShStrTab.Content.finalize();
211 ShStrTab.Size = ShStrTab.Content.getSize();
212 DynStr.Content.finalize();
213 DynStr.Size = DynStr.Content.getSize();
214
215 // Populate dynamic symbol table.
216 for (const ELFSymbol &Sym : Stub.Symbols) {
217 uint8_t Bind = Sym.Weak ? STB_WEAK : STB_GLOBAL;
218 // For non-undefined symbols, value of the shndx is not relevant at link
219 // time as long as it is not SHN_UNDEF. Set shndx to 1, which
220 // points to ".dynsym".
221 uint16_t Shndx = Sym.Undefined ? SHN_UNDEF : 1;
222 DynSym.Content.add(DynStr.Content.getOffset(Sym.Name), Sym.Size, Bind,
223 (uint8_t)Sym.Type, 0, Shndx);
224 }
225 DynSym.Size = DynSym.Content.getSize();
226
227 // Poplulate dynamic table.
228 size_t DynSymIndex = DynTab.Content.addAddr(DT_SYMTAB, 0);
229 size_t DynStrIndex = DynTab.Content.addAddr(DT_STRTAB, 0);
230 for (const std::string &Lib : Stub.NeededLibs)
231 DynTab.Content.addValue(DT_NEEDED, DynStr.Content.getOffset(Lib));
232 if (Stub.SoName)
233 DynTab.Content.addValue(DT_SONAME,
234 DynStr.Content.getOffset(Stub.SoName.getValue()));
235 DynTab.Size = DynTab.Content.getSize();
236 // Calculate sections' addresses and offsets.
237 uint64_t CurrentOffset = sizeof(Elf_Ehdr);
238 for (OutputSection<ELFT> *Sec : Sections) {
239 Sec->Offset = alignTo(CurrentOffset, Sec->Align);
240 Sec->Addr = Sec->Offset;
241 CurrentOffset = Sec->Offset + Sec->Size;
242 }
243 // Fill Addr back to dynamic table.
244 DynTab.Content.modifyAddr(DynSymIndex, DynSym.Addr);
245 DynTab.Content.modifyAddr(DynStrIndex, DynStr.Addr);
246 // Write section headers of string tables.
247 fillSymTabShdr(DynSym, SHT_DYNSYM);
248 fillStrTabShdr(DynStr, SHF_ALLOC);
249 fillDynTabShdr(DynTab);
250 fillStrTabShdr(ShStrTab);
251
252 // Finish initializing the ELF header.
253 initELFHeader<ELFT>(ElfHeader, Stub.Arch);
254 ElfHeader.e_shstrndx = ShStrTab.Index;
255 ElfHeader.e_shnum = LastSection->Index + 1;
256 ElfHeader.e_shoff =
257 alignTo(LastSection->Offset + LastSection->Size, sizeof(Elf_Addr));
258 }
259
getSize() const260 size_t getSize() const {
261 return ElfHeader.e_shoff + ElfHeader.e_shnum * sizeof(Elf_Shdr);
262 }
263
write(uint8_t * Data) const264 void write(uint8_t *Data) const {
265 write(Data, ElfHeader);
266 DynSym.Content.write(Data + DynSym.Shdr.sh_offset);
267 DynStr.Content.write(Data + DynStr.Shdr.sh_offset);
268 DynTab.Content.write(Data + DynTab.Shdr.sh_offset);
269 ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset);
270 writeShdr(Data, DynSym);
271 writeShdr(Data, DynStr);
272 writeShdr(Data, DynTab);
273 writeShdr(Data, ShStrTab);
274 }
275
276 private:
277 Elf_Ehdr ElfHeader;
278 ContentSection<ELFStringTableBuilder, ELFT> DynStr;
279 ContentSection<ELFStringTableBuilder, ELFT> ShStrTab;
280 ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> DynSym;
281 ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> DynTab;
282
write(uint8_t * Data,const T & Value)283 template <class T> static void write(uint8_t *Data, const T &Value) {
284 *reinterpret_cast<T *>(Data) = Value;
285 }
286
fillStrTabShdr(ContentSection<ELFStringTableBuilder,ELFT> & StrTab,uint32_t ShFlags=0) const287 void fillStrTabShdr(ContentSection<ELFStringTableBuilder, ELFT> &StrTab,
288 uint32_t ShFlags = 0) const {
289 StrTab.Shdr.sh_type = SHT_STRTAB;
290 StrTab.Shdr.sh_flags = ShFlags;
291 StrTab.Shdr.sh_addr = StrTab.Addr;
292 StrTab.Shdr.sh_offset = StrTab.Offset;
293 StrTab.Shdr.sh_info = 0;
294 StrTab.Shdr.sh_size = StrTab.Size;
295 StrTab.Shdr.sh_name = ShStrTab.Content.getOffset(StrTab.Name);
296 StrTab.Shdr.sh_addralign = StrTab.Align;
297 StrTab.Shdr.sh_entsize = 0;
298 StrTab.Shdr.sh_link = 0;
299 }
fillSymTabShdr(ContentSection<ELFSymbolTableBuilder<ELFT>,ELFT> & SymTab,uint32_t ShType) const300 void fillSymTabShdr(ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> &SymTab,
301 uint32_t ShType) const {
302 SymTab.Shdr.sh_type = ShType;
303 SymTab.Shdr.sh_flags = SHF_ALLOC;
304 SymTab.Shdr.sh_addr = SymTab.Addr;
305 SymTab.Shdr.sh_offset = SymTab.Offset;
306 // Only non-local symbols are included in the tbe file, so .dynsym only
307 // contains 1 local symbol (the undefined symbol at index 0). The sh_info
308 // should always be 1.
309 SymTab.Shdr.sh_info = 1;
310 SymTab.Shdr.sh_size = SymTab.Size;
311 SymTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(SymTab.Name);
312 SymTab.Shdr.sh_addralign = SymTab.Align;
313 SymTab.Shdr.sh_entsize = sizeof(Elf_Sym);
314 SymTab.Shdr.sh_link = this->DynStr.Index;
315 }
fillDynTabShdr(ContentSection<ELFDynamicTableBuilder<ELFT>,ELFT> & DynTab) const316 void fillDynTabShdr(
317 ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> &DynTab) const {
318 DynTab.Shdr.sh_type = SHT_DYNAMIC;
319 DynTab.Shdr.sh_flags = SHF_ALLOC;
320 DynTab.Shdr.sh_addr = DynTab.Addr;
321 DynTab.Shdr.sh_offset = DynTab.Offset;
322 DynTab.Shdr.sh_info = 0;
323 DynTab.Shdr.sh_size = DynTab.Size;
324 DynTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(DynTab.Name);
325 DynTab.Shdr.sh_addralign = DynTab.Align;
326 DynTab.Shdr.sh_entsize = sizeof(Elf_Dyn);
327 DynTab.Shdr.sh_link = this->DynStr.Index;
328 }
shdrOffset(const OutputSection<ELFT> & Sec) const329 uint64_t shdrOffset(const OutputSection<ELFT> &Sec) const {
330 return ElfHeader.e_shoff + Sec.Index * sizeof(Elf_Shdr);
331 }
332
writeShdr(uint8_t * Data,const OutputSection<ELFT> & Sec) const333 void writeShdr(uint8_t *Data, const OutputSection<ELFT> &Sec) const {
334 write(Data + shdrOffset(Sec), Sec.Shdr);
335 }
336 };
337 } // end anonymous namespace
338
339 /// This function behaves similarly to StringRef::substr(), but attempts to
340 /// terminate the returned StringRef at the first null terminator. If no null
341 /// terminator is found, an error is returned.
342 ///
343 /// @param Str Source string to create a substring from.
344 /// @param Offset The start index of the desired substring.
terminatedSubstr(StringRef Str,size_t Offset)345 static Expected<StringRef> terminatedSubstr(StringRef Str, size_t Offset) {
346 size_t StrEnd = Str.find('\0', Offset);
347 if (StrEnd == StringLiteral::npos) {
348 return createError(
349 "String overran bounds of string table (no null terminator)");
350 }
351
352 size_t StrLen = StrEnd - Offset;
353 return Str.substr(Offset, StrLen);
354 }
355
356 /// This function takes an error, and appends a string of text to the end of
357 /// that error. Since "appending" to an Error isn't supported behavior of an
358 /// Error, this function technically creates a new error with the combined
359 /// message and consumes the old error.
360 ///
361 /// @param Err Source error.
362 /// @param After Text to append at the end of Err's error message.
appendToError(Error Err,StringRef After)363 Error appendToError(Error Err, StringRef After) {
364 std::string Message;
365 raw_string_ostream Stream(Message);
366 Stream << Err;
367 Stream << " " << After;
368 consumeError(std::move(Err));
369 return createError(Stream.str().c_str());
370 }
371
372 /// This function populates a DynamicEntries struct using an ELFT::DynRange.
373 /// After populating the struct, the members are validated with
374 /// some basic sanity checks.
375 ///
376 /// @param Dyn Target DynamicEntries struct to populate.
377 /// @param DynTable Source dynamic table.
378 template <class ELFT>
populateDynamic(DynamicEntries & Dyn,typename ELFT::DynRange DynTable)379 static Error populateDynamic(DynamicEntries &Dyn,
380 typename ELFT::DynRange DynTable) {
381 if (DynTable.empty())
382 return createError("No .dynamic section found");
383
384 // Search .dynamic for relevant entries.
385 bool FoundDynStr = false;
386 bool FoundDynStrSz = false;
387 bool FoundDynSym = false;
388 for (auto &Entry : DynTable) {
389 switch (Entry.d_tag) {
390 case DT_SONAME:
391 Dyn.SONameOffset = Entry.d_un.d_val;
392 break;
393 case DT_STRTAB:
394 Dyn.StrTabAddr = Entry.d_un.d_ptr;
395 FoundDynStr = true;
396 break;
397 case DT_STRSZ:
398 Dyn.StrSize = Entry.d_un.d_val;
399 FoundDynStrSz = true;
400 break;
401 case DT_NEEDED:
402 Dyn.NeededLibNames.push_back(Entry.d_un.d_val);
403 break;
404 case DT_SYMTAB:
405 Dyn.DynSymAddr = Entry.d_un.d_ptr;
406 FoundDynSym = true;
407 break;
408 case DT_HASH:
409 Dyn.ElfHash = Entry.d_un.d_ptr;
410 break;
411 case DT_GNU_HASH:
412 Dyn.GnuHash = Entry.d_un.d_ptr;
413 }
414 }
415
416 if (!FoundDynStr) {
417 return createError(
418 "Couldn't locate dynamic string table (no DT_STRTAB entry)");
419 }
420 if (!FoundDynStrSz) {
421 return createError(
422 "Couldn't determine dynamic string table size (no DT_STRSZ entry)");
423 }
424 if (!FoundDynSym) {
425 return createError(
426 "Couldn't locate dynamic symbol table (no DT_SYMTAB entry)");
427 }
428 if (Dyn.SONameOffset.hasValue() && *Dyn.SONameOffset >= Dyn.StrSize) {
429 return createStringError(object_error::parse_failed,
430 "DT_SONAME string offset (0x%016" PRIx64
431 ") outside of dynamic string table",
432 *Dyn.SONameOffset);
433 }
434 for (uint64_t Offset : Dyn.NeededLibNames) {
435 if (Offset >= Dyn.StrSize) {
436 return createStringError(object_error::parse_failed,
437 "DT_NEEDED string offset (0x%016" PRIx64
438 ") outside of dynamic string table",
439 Offset);
440 }
441 }
442
443 return Error::success();
444 }
445
446 /// This function extracts symbol type from a symbol's st_info member and
447 /// maps it to an ELFSymbolType enum.
448 /// Currently, STT_NOTYPE, STT_OBJECT, STT_FUNC, and STT_TLS are supported.
449 /// Other symbol types are mapped to ELFSymbolType::Unknown.
450 ///
451 /// @param Info Binary symbol st_info to extract symbol type from.
convertInfoToType(uint8_t Info)452 static ELFSymbolType convertInfoToType(uint8_t Info) {
453 Info = Info & 0xf;
454 switch (Info) {
455 case ELF::STT_NOTYPE:
456 return ELFSymbolType::NoType;
457 case ELF::STT_OBJECT:
458 return ELFSymbolType::Object;
459 case ELF::STT_FUNC:
460 return ELFSymbolType::Func;
461 case ELF::STT_TLS:
462 return ELFSymbolType::TLS;
463 default:
464 return ELFSymbolType::Unknown;
465 }
466 }
467
468 /// This function creates an ELFSymbol and populates all members using
469 /// information from a binary ELFT::Sym.
470 ///
471 /// @param SymName The desired name of the ELFSymbol.
472 /// @param RawSym ELFT::Sym to extract symbol information from.
473 template <class ELFT>
createELFSym(StringRef SymName,const typename ELFT::Sym & RawSym)474 static ELFSymbol createELFSym(StringRef SymName,
475 const typename ELFT::Sym &RawSym) {
476 ELFSymbol TargetSym{std::string(SymName)};
477 uint8_t Binding = RawSym.getBinding();
478 if (Binding == STB_WEAK)
479 TargetSym.Weak = true;
480 else
481 TargetSym.Weak = false;
482
483 TargetSym.Undefined = RawSym.isUndefined();
484 TargetSym.Type = convertInfoToType(RawSym.st_info);
485
486 if (TargetSym.Type == ELFSymbolType::Func) {
487 TargetSym.Size = 0;
488 } else {
489 TargetSym.Size = RawSym.st_size;
490 }
491 return TargetSym;
492 }
493
494 /// This function populates an ELFStub with symbols using information read
495 /// from an ELF binary.
496 ///
497 /// @param TargetStub ELFStub to add symbols to.
498 /// @param DynSym Range of dynamic symbols to add to TargetStub.
499 /// @param DynStr StringRef to the dynamic string table.
500 template <class ELFT>
populateSymbols(ELFStub & TargetStub,const typename ELFT::SymRange DynSym,StringRef DynStr)501 static Error populateSymbols(ELFStub &TargetStub,
502 const typename ELFT::SymRange DynSym,
503 StringRef DynStr) {
504 // Skips the first symbol since it's the NULL symbol.
505 for (auto RawSym : DynSym.drop_front(1)) {
506 // If a symbol does not have global or weak binding, ignore it.
507 uint8_t Binding = RawSym.getBinding();
508 if (!(Binding == STB_GLOBAL || Binding == STB_WEAK))
509 continue;
510 // If a symbol doesn't have default or protected visibility, ignore it.
511 uint8_t Visibility = RawSym.getVisibility();
512 if (!(Visibility == STV_DEFAULT || Visibility == STV_PROTECTED))
513 continue;
514 // Create an ELFSymbol and populate it with information from the symbol
515 // table entry.
516 Expected<StringRef> SymName = terminatedSubstr(DynStr, RawSym.st_name);
517 if (!SymName)
518 return SymName.takeError();
519 ELFSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);
520 TargetStub.Symbols.insert(std::move(Sym));
521 // TODO: Populate symbol warning.
522 }
523 return Error::success();
524 }
525
526 /// Returns a new ELFStub with all members populated from an ELFObjectFile.
527 /// @param ElfObj Source ELFObjectFile.
528 template <class ELFT>
529 static Expected<std::unique_ptr<ELFStub>>
buildStub(const ELFObjectFile<ELFT> & ElfObj)530 buildStub(const ELFObjectFile<ELFT> &ElfObj) {
531 using Elf_Dyn_Range = typename ELFT::DynRange;
532 using Elf_Phdr_Range = typename ELFT::PhdrRange;
533 using Elf_Sym_Range = typename ELFT::SymRange;
534 using Elf_Sym = typename ELFT::Sym;
535 std::unique_ptr<ELFStub> DestStub = std::make_unique<ELFStub>();
536 const ELFFile<ELFT> &ElfFile = ElfObj.getELFFile();
537 // Fetch .dynamic table.
538 Expected<Elf_Dyn_Range> DynTable = ElfFile.dynamicEntries();
539 if (!DynTable) {
540 return DynTable.takeError();
541 }
542
543 // Fetch program headers.
544 Expected<Elf_Phdr_Range> PHdrs = ElfFile.program_headers();
545 if (!PHdrs) {
546 return PHdrs.takeError();
547 }
548
549 // Collect relevant .dynamic entries.
550 DynamicEntries DynEnt;
551 if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))
552 return std::move(Err);
553
554 // Get pointer to in-memory location of .dynstr section.
555 Expected<const uint8_t *> DynStrPtr = ElfFile.toMappedAddr(DynEnt.StrTabAddr);
556 if (!DynStrPtr)
557 return appendToError(DynStrPtr.takeError(),
558 "when locating .dynstr section contents");
559
560 StringRef DynStr(reinterpret_cast<const char *>(DynStrPtr.get()),
561 DynEnt.StrSize);
562
563 // Populate Arch from ELF header.
564 DestStub->Arch = ElfFile.getHeader().e_machine;
565
566 // Populate SoName from .dynamic entries and dynamic string table.
567 if (DynEnt.SONameOffset.hasValue()) {
568 Expected<StringRef> NameOrErr =
569 terminatedSubstr(DynStr, *DynEnt.SONameOffset);
570 if (!NameOrErr) {
571 return appendToError(NameOrErr.takeError(), "when reading DT_SONAME");
572 }
573 DestStub->SoName = std::string(*NameOrErr);
574 }
575
576 // Populate NeededLibs from .dynamic entries and dynamic string table.
577 for (uint64_t NeededStrOffset : DynEnt.NeededLibNames) {
578 Expected<StringRef> LibNameOrErr =
579 terminatedSubstr(DynStr, NeededStrOffset);
580 if (!LibNameOrErr) {
581 return appendToError(LibNameOrErr.takeError(), "when reading DT_NEEDED");
582 }
583 DestStub->NeededLibs.push_back(std::string(*LibNameOrErr));
584 }
585
586 // Populate Symbols from .dynsym table and dynamic string table.
587 Expected<uint64_t> SymCount = ElfFile.getDynSymtabSize();
588 if (!SymCount)
589 return SymCount.takeError();
590 if (*SymCount > 0) {
591 // Get pointer to in-memory location of .dynsym section.
592 Expected<const uint8_t *> DynSymPtr =
593 ElfFile.toMappedAddr(DynEnt.DynSymAddr);
594 if (!DynSymPtr)
595 return appendToError(DynSymPtr.takeError(),
596 "when locating .dynsym section contents");
597 Elf_Sym_Range DynSyms = ArrayRef<Elf_Sym>(
598 reinterpret_cast<const Elf_Sym *>(*DynSymPtr), *SymCount);
599 Error SymReadError = populateSymbols<ELFT>(*DestStub, DynSyms, DynStr);
600 if (SymReadError)
601 return appendToError(std::move(SymReadError),
602 "when reading dynamic symbols");
603 }
604
605 return std::move(DestStub);
606 }
607
608 /// This function opens a file for writing and then writes a binary ELF stub to
609 /// the file.
610 ///
611 /// @param FilePath File path for writing the ELF binary.
612 /// @param Stub Source ELFStub to generate a binary ELF stub from.
613 template <class ELFT>
writeELFBinaryToFile(StringRef FilePath,const ELFStub & Stub,bool WriteIfChanged)614 static Error writeELFBinaryToFile(StringRef FilePath, const ELFStub &Stub,
615 bool WriteIfChanged) {
616 ELFStubBuilder<ELFT> Builder{Stub};
617 // Write Stub to memory first.
618 std::vector<uint8_t> Buf(Builder.getSize());
619 Builder.write(Buf.data());
620
621 if (WriteIfChanged) {
622 if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
623 MemoryBuffer::getFile(FilePath)) {
624 // Compare Stub output with existing Stub file.
625 // If Stub file unchanged, abort updating.
626 if ((*BufOrError)->getBufferSize() == Builder.getSize() &&
627 !memcmp((*BufOrError)->getBufferStart(), Buf.data(),
628 Builder.getSize()))
629 return Error::success();
630 }
631 }
632
633 Expected<std::unique_ptr<FileOutputBuffer>> BufOrError =
634 FileOutputBuffer::create(FilePath, Builder.getSize());
635 if (!BufOrError)
636 return createStringError(errc::invalid_argument,
637 toString(BufOrError.takeError()) +
638 " when trying to open `" + FilePath +
639 "` for writing");
640
641 // Write binary to file.
642 std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);
643 memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());
644
645 return FileBuf->commit();
646 }
647
readELFFile(MemoryBufferRef Buf)648 Expected<std::unique_ptr<ELFStub>> readELFFile(MemoryBufferRef Buf) {
649 Expected<std::unique_ptr<Binary>> BinOrErr = createBinary(Buf);
650 if (!BinOrErr) {
651 return BinOrErr.takeError();
652 }
653
654 Binary *Bin = BinOrErr->get();
655 if (auto Obj = dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {
656 return buildStub(*Obj);
657 } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {
658 return buildStub(*Obj);
659 } else if (auto Obj = dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {
660 return buildStub(*Obj);
661 } else if (auto Obj = dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {
662 return buildStub(*Obj);
663 }
664 return createStringError(errc::not_supported, "unsupported binary format");
665 }
666
667 // This function wraps the ELFT writeELFBinaryToFile() so writeBinaryStub()
668 // can be called without having to use ELFType templates directly.
writeBinaryStub(StringRef FilePath,const ELFStub & Stub,ELFTarget OutputFormat,bool WriteIfChanged)669 Error writeBinaryStub(StringRef FilePath, const ELFStub &Stub,
670 ELFTarget OutputFormat, bool WriteIfChanged) {
671 if (OutputFormat == ELFTarget::ELF32LE)
672 return writeELFBinaryToFile<ELF32LE>(FilePath, Stub, WriteIfChanged);
673 if (OutputFormat == ELFTarget::ELF32BE)
674 return writeELFBinaryToFile<ELF32BE>(FilePath, Stub, WriteIfChanged);
675 if (OutputFormat == ELFTarget::ELF64LE)
676 return writeELFBinaryToFile<ELF64LE>(FilePath, Stub, WriteIfChanged);
677 if (OutputFormat == ELFTarget::ELF64BE)
678 return writeELFBinaryToFile<ELF64BE>(FilePath, Stub, WriteIfChanged);
679 llvm_unreachable("invalid binary output target");
680 }
681
682 } // end namespace elfabi
683 } // end namespace llvm
684