Movatterモバイル変換

Go to the documentation of this file.

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//===-----------------------------------------------------------------------===/

9#include "llvm/InterfaceStub/ELFObjHandler.h"

10#include "llvm/InterfaceStub/IFSStub.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 <optional>

22usingllvm::object::ELFObjectFile;

24using namespacellvm;

25using namespacellvm::object;

26using namespacellvm::ELF;

28namespacellvm {

29namespaceifs {

31// Simple struct to hold relevant .dynamic entries.

32structDynamicEntries {

33uint64_t StrTabAddr = 0;

34uint64_t StrSize = 0;

35 std::optional<uint64_t>SONameOffset;

36 std::vector<uint64_t>NeededLibNames;

37// Symbol table:

38uint64_t DynSymAddr = 0;

39// Hash tables:

40 std::optional<uint64_t>ElfHash;

41 std::optional<uint64_t>GnuHash;

42};

44/// This initializes an ELF file header with information specific to a binary

45/// dynamic shared object.

46/// Offsets, indexes, links, etc. for section and program headers are just

47/// zero-initialized as they will be updated elsewhere.

48///

49/// @param ElfHeader Target ELFT::Ehdr to populate.

50/// @param Machine Target architecture (e_machine from ELF specifications).

51template <class ELFT>

52staticvoidinitELFHeader(typename ELFT::Ehdr &ElfHeader,uint16_t Machine) {

53 memset(&ElfHeader, 0,sizeof(ElfHeader));

54// ELF identification.

55 ElfHeader.e_ident[EI_MAG0] =ElfMagic[EI_MAG0];

56 ElfHeader.e_ident[EI_MAG1] =ElfMagic[EI_MAG1];

57 ElfHeader.e_ident[EI_MAG2] =ElfMagic[EI_MAG2];

58 ElfHeader.e_ident[EI_MAG3] =ElfMagic[EI_MAG3];

59 ElfHeader.e_ident[EI_CLASS] = ELFT::Is64Bits ?ELFCLASS64 :ELFCLASS32;

60bool IsLittleEndian = ELFT::Endianness ==llvm::endianness::little;

61 ElfHeader.e_ident[EI_DATA] = IsLittleEndian ?ELFDATA2LSB :ELFDATA2MSB;

62 ElfHeader.e_ident[EI_VERSION] =EV_CURRENT;

63 ElfHeader.e_ident[EI_OSABI] =ELFOSABI_NONE;

65// Remainder of ELF header.

66 ElfHeader.e_type =ET_DYN;

67 ElfHeader.e_machine =Machine;

68 ElfHeader.e_version =EV_CURRENT;

69 ElfHeader.e_ehsize =sizeof(typename ELFT::Ehdr);

70 ElfHeader.e_phentsize =sizeof(typename ELFT::Phdr);

71 ElfHeader.e_shentsize =sizeof(typename ELFT::Shdr);

72}

74namespace{

75template <class ELFT>structOutputSection {

76usingElf_Shdr =typename ELFT::Shdr;

77 std::string Name;

78 Elf_ShdrShdr;

79uint64_t Addr;

80uint64_t Offset;

81uint64_t Size;

82uint64_t Align;

83uint32_t Index;

84boolNoBits =true;

85};

87template <class T,class ELFT>

88structContentSection :public OutputSection<ELFT> {

89T Content;

90 ContentSection() { this->NoBits =false; }

91};

93// This class just wraps StringTableBuilder for the purpose of adding a

94// default constructor.

95classELFStringTableBuilder :publicStringTableBuilder {

96public:

97 ELFStringTableBuilder() :StringTableBuilder(StringTableBuilder::ELF) {}

98};

100template <class ELFT>classELFSymbolTableBuilder {

101public:

102usingElf_Sym =typename ELFT::Sym;

103

104 ELFSymbolTableBuilder() { Symbols.push_back({}); }

105

106voidadd(size_t StNameOffset,uint64_t StSize,uint8_t StBind,uint8_t StType,

107uint8_t StOther,uint16_t StShndx) {

108 Elf_Sym S{};

109 S.st_name = StNameOffset;

110 S.st_size = StSize;

111 S.st_info = (StBind << 4) | (StType & 0xf);

112 S.st_other = StOther;

113 S.st_shndx = StShndx;

114 Symbols.push_back(S);

115 }

116

117size_tgetSize() const{return Symbols.size() *sizeof(Elf_Sym); }

118

119voidwrite(uint8_t *Buf) const{

120 memcpy(Buf, Symbols.data(),sizeof(Elf_Sym) * Symbols.size());

121 }

122

123private:

124llvm::SmallVector<Elf_Sym, 8> Symbols;

125};

126

127template <class ELFT>classELFDynamicTableBuilder {

128public:

129usingElf_Dyn =typename ELFT::Dyn;

130

131size_t addAddr(uint64_t Tag,uint64_t Addr) {

132 Elf_DynEntry;

133Entry.d_tag =Tag;

134Entry.d_un.d_ptr =Addr;

135 Entries.push_back(Entry);

136return Entries.size() - 1;

137 }

138

139void modifyAddr(size_t Index,uint64_t Addr) {

140 Entries[Index].d_un.d_ptr =Addr;

141 }

142

143size_t addValue(uint64_t Tag,uint64_t Value) {

144 Elf_DynEntry;

145Entry.d_tag =Tag;

146Entry.d_un.d_val =Value;

147 Entries.push_back(Entry);

148return Entries.size() - 1;

149 }

150

151void modifyValue(size_t Index,uint64_t Value) {

152 Entries[Index].d_un.d_val =Value;

153 }

154

155size_tgetSize() const{

156// Add DT_NULL entry at the end.

157return (Entries.size() + 1) *sizeof(Elf_Dyn);

158 }

159

160voidwrite(uint8_t *Buf) const{

161 memcpy(Buf, Entries.data(),sizeof(Elf_Dyn) * Entries.size());

162// Add DT_NULL entry at the end.

163 memset(Buf +sizeof(Elf_Dyn) * Entries.size(), 0,sizeof(Elf_Dyn));

164 }

165

166private:

167llvm::SmallVector<Elf_Dyn, 8> Entries;

168};

169

170template <class ELFT>classELFStubBuilder {

171public:

172usingElf_Ehdr =typename ELFT::Ehdr;

173usingElf_Shdr =typename ELFT::Shdr;

174usingElf_Phdr =typename ELFT::Phdr;

175usingElf_Sym =typename ELFT::Sym;

176usingElf_Addr =typename ELFT::Addr;

177usingElf_Dyn =typename ELFT::Dyn;

178

179 ELFStubBuilder(const ELFStubBuilder &) =delete;

180 ELFStubBuilder(ELFStubBuilder &&) =default;

181

182explicit ELFStubBuilder(const IFSStub &Stub) {

183 DynSym.Name =".dynsym";

184 DynSym.Align =sizeof(Elf_Addr);

185 DynStr.Name =".dynstr";

186 DynStr.Align = 1;

187 DynTab.Name =".dynamic";

188 DynTab.Align =sizeof(Elf_Addr);

189 ShStrTab.Name =".shstrtab";

190 ShStrTab.Align = 1;

191

192// Populate string tables.

193for (const IFSSymbol &Sym : Stub.Symbols)

194 DynStr.Content.add(Sym.Name);

195for (const std::string &Lib : Stub.NeededLibs)

196 DynStr.Content.add(Lib);

197if (Stub.SoName)

198 DynStr.Content.add(*Stub.SoName);

199

200 std::vector<OutputSection<ELFT> *> Sections = {&DynSym, &DynStr, &DynTab,

201 &ShStrTab};

202const OutputSection<ELFT> *LastSection = Sections.back();

203// Now set the Index and put sections names into ".shstrtab".

204uint64_t Index = 1;

205for (OutputSection<ELFT> *Sec : Sections) {

206 Sec->Index =Index++;

207 ShStrTab.Content.add(Sec->Name);

208 }

209 ShStrTab.Content.finalize();

210 ShStrTab.Size = ShStrTab.Content.getSize();

211 DynStr.Content.finalize();

212 DynStr.Size = DynStr.Content.getSize();

213

214// Populate dynamic symbol table.

215for (const IFSSymbol &Sym : Stub.Symbols) {

216uint8_t Bind =Sym.Weak ?STB_WEAK :STB_GLOBAL;

217// For non-undefined symbols, value of the shndx is not relevant at link

218// time as long as it is not SHN_UNDEF. Set shndx to 1, which

219// points to ".dynsym".

220uint16_t Shndx =Sym.Undefined ?SHN_UNDEF : 1;

221uint64_t Size =Sym.Size.value_or(0);

222 DynSym.Content.add(DynStr.Content.getOffset(Sym.Name),Size, Bind,

223convertIFSSymbolTypeToELF(Sym.Type), 0, Shndx);

224 }

225 DynSym.Size = DynSym.Content.getSize();

226

227// Poplulate dynamic table.

228size_t DynSymIndex = DynTab.Content.addAddr(DT_SYMTAB, 0);

229size_t DynStrIndex = DynTab.Content.addAddr(DT_STRTAB, 0);

230 DynTab.Content.addValue(DT_STRSZ, DynSym.Size);

231for (const std::string &Lib : Stub.NeededLibs)

232 DynTab.Content.addValue(DT_NEEDED, DynStr.Content.getOffset(Lib));

233if (Stub.SoName)

234 DynTab.Content.addValue(DT_SONAME,

235 DynStr.Content.getOffset(*Stub.SoName));

236 DynTab.Size = DynTab.Content.getSize();

237// Calculate sections' addresses and offsets.

238uint64_t CurrentOffset =sizeof(Elf_Ehdr);

239for (OutputSection<ELFT> *Sec : Sections) {

240 Sec->Offset =alignTo(CurrentOffset, Sec->Align);

241 Sec->Addr = Sec->Offset;

242 CurrentOffset = Sec->Offset + Sec->Size;

243 }

244// Fill Addr back to dynamic table.

245 DynTab.Content.modifyAddr(DynSymIndex, DynSym.Addr);

246 DynTab.Content.modifyAddr(DynStrIndex, DynStr.Addr);

247// Write section headers of string tables.

248 fillSymTabShdr(DynSym,SHT_DYNSYM);

249 fillStrTabShdr(DynStr,SHF_ALLOC);

250 fillDynTabShdr(DynTab);

251 fillStrTabShdr(ShStrTab);

252

253// Finish initializing the ELF header.

254 initELFHeader<ELFT>(ElfHeader,static_cast<uint16_t>(*Stub.Target.Arch));

255 ElfHeader.e_shstrndx = ShStrTab.Index;

256 ElfHeader.e_shnum = LastSection->Index + 1;

257 ElfHeader.e_shoff =

258alignTo(LastSection->Offset + LastSection->Size,sizeof(Elf_Addr));

259 }

260

261size_tgetSize() const{

262return ElfHeader.e_shoff + ElfHeader.e_shnum *sizeof(Elf_Shdr);

263 }

264

265voidwrite(uint8_t *Data) const{

266write(Data, ElfHeader);

267 DynSym.Content.write(Data + DynSym.Shdr.sh_offset);

268 DynStr.Content.write(Data + DynStr.Shdr.sh_offset);

269 DynTab.Content.write(Data + DynTab.Shdr.sh_offset);

270 ShStrTab.Content.write(Data + ShStrTab.Shdr.sh_offset);

271 writeShdr(Data, DynSym);

272 writeShdr(Data, DynStr);

273 writeShdr(Data, DynTab);

274 writeShdr(Data, ShStrTab);

275 }

276

277private:

278 Elf_Ehdr ElfHeader;

279 ContentSection<ELFStringTableBuilder, ELFT> DynStr;

280 ContentSection<ELFStringTableBuilder, ELFT> ShStrTab;

281 ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> DynSym;

282 ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> DynTab;

283

284template <class T>staticvoidwrite(uint8_t *Data,constT &Value) {

285 *reinterpret_cast<T *>(Data) =Value;

286 }

287

288void fillStrTabShdr(ContentSection<ELFStringTableBuilder, ELFT> &StrTab,

289uint32_t ShFlags = 0) const{

290 StrTab.Shdr.sh_type =SHT_STRTAB;

291 StrTab.Shdr.sh_flags = ShFlags;

292 StrTab.Shdr.sh_addr = StrTab.Addr;

293 StrTab.Shdr.sh_offset = StrTab.Offset;

294 StrTab.Shdr.sh_info = 0;

295 StrTab.Shdr.sh_size = StrTab.Size;

296 StrTab.Shdr.sh_name = ShStrTab.Content.getOffset(StrTab.Name);

297 StrTab.Shdr.sh_addralign = StrTab.Align;

298 StrTab.Shdr.sh_entsize = 0;

299 StrTab.Shdr.sh_link = 0;

300 }

301void fillSymTabShdr(ContentSection<ELFSymbolTableBuilder<ELFT>, ELFT> &SymTab,

302uint32_t ShType) const{

303 SymTab.Shdr.sh_type = ShType;

304 SymTab.Shdr.sh_flags =SHF_ALLOC;

305 SymTab.Shdr.sh_addr = SymTab.Addr;

306 SymTab.Shdr.sh_offset = SymTab.Offset;

307// Only non-local symbols are included in the tbe file, so .dynsym only

308// contains 1 local symbol (the undefined symbol at index 0). The sh_info

309// should always be 1.

310 SymTab.Shdr.sh_info = 1;

311 SymTab.Shdr.sh_size = SymTab.Size;

312 SymTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(SymTab.Name);

313 SymTab.Shdr.sh_addralign = SymTab.Align;

314 SymTab.Shdr.sh_entsize =sizeof(Elf_Sym);

315 SymTab.Shdr.sh_link = this->DynStr.Index;

316 }

317void fillDynTabShdr(

318 ContentSection<ELFDynamicTableBuilder<ELFT>, ELFT> &DynTab) const{

319 DynTab.Shdr.sh_type =SHT_DYNAMIC;

320 DynTab.Shdr.sh_flags =SHF_ALLOC;

321 DynTab.Shdr.sh_addr = DynTab.Addr;

322 DynTab.Shdr.sh_offset = DynTab.Offset;

323 DynTab.Shdr.sh_info = 0;

324 DynTab.Shdr.sh_size = DynTab.Size;

325 DynTab.Shdr.sh_name = this->ShStrTab.Content.getOffset(DynTab.Name);

326 DynTab.Shdr.sh_addralign = DynTab.Align;

327 DynTab.Shdr.sh_entsize =sizeof(Elf_Dyn);

328 DynTab.Shdr.sh_link = this->DynStr.Index;

329 }

330uint64_t shdrOffset(const OutputSection<ELFT> &Sec) const{

331return ElfHeader.e_shoff + Sec.Index *sizeof(Elf_Shdr);

332 }

333

334void writeShdr(uint8_t *Data,const OutputSection<ELFT> &Sec) const{

335write(Data + shdrOffset(Sec), Sec.Shdr);

336 }

337};

338

339/// This function takes an error, and appends a string of text to the end of

340/// that error. Since "appending" to an Error isn't supported behavior of an

341/// Error, this function technically creates a new error with the combined

342/// message and consumes the old error.

343///

344/// @param Err Source error.

345/// @param After Text to append at the end of Err's error message.

346Error appendToError(Error Err,StringRef After) {

347 std::string Message;

348raw_string_ostream Stream(Message);

349 Stream << Err;

350 Stream <<" " <<After;

351consumeError(std::move(Err));

352returncreateError(Stream.str());

353}

354

355template <class ELFT>classDynSym {

356usingElf_Shdr_Range =typename ELFT::ShdrRange;

357usingElf_Shdr =typename ELFT::Shdr;

358

359public:

360staticExpected<DynSym> create(constELFFile<ELFT> &ElfFile,

361const DynamicEntries &DynEnt) {

362Expected<Elf_Shdr_Range> Shdrs = ElfFile.sections();

363if (!Shdrs)

364return Shdrs.takeError();

365return DynSym(ElfFile, DynEnt, *Shdrs);

366 }

367

368Expected<const uint8_t *> getDynSym() {

369if (DynSymHdr)

370return ElfFile.base() + DynSymHdr->sh_offset;

371return getDynamicData(DynEnt.DynSymAddr,"dynamic symbol table");

372 }

373

374Expected<StringRef> getDynStr() {

375if (DynSymHdr)

376return ElfFile.getStringTableForSymtab(*DynSymHdr, Shdrs);

377Expected<const uint8_t *> DataOrErr = getDynamicData(

378 DynEnt.StrTabAddr,"dynamic string table", DynEnt.StrSize);

379if (!DataOrErr)

380return DataOrErr.takeError();

381returnStringRef(reinterpret_cast<constchar *>(*DataOrErr),

382 DynEnt.StrSize);

383 }

384

385private:

386 DynSym(constELFFile<ELFT> &ElfFile,const DynamicEntries &DynEnt,

387 Elf_Shdr_Range Shdrs)

388 : ElfFile(ElfFile), DynEnt(DynEnt), Shdrs(Shdrs),

389 DynSymHdr(findDynSymHdr()) {}

390

391const Elf_Shdr *findDynSymHdr() {

392for (const Elf_Shdr &Sec : Shdrs)

393if (Sec.sh_type ==SHT_DYNSYM) {

394// If multiple .dynsym are present, use the first one.

395// This behavior aligns with llvm::object::ELFFile::getDynSymtabSize()

396return &Sec;

397 }

398returnnullptr;

399 }

400

401Expected<const uint8_t *> getDynamicData(uint64_t EntAddr,StringRef Name,

402uint64_t Size = 0) {

403Expected<const uint8_t *> SecPtr = ElfFile.toMappedAddr(EntAddr);

404if (!SecPtr)

405return appendToError(

406 SecPtr.takeError(),

407 ("when locating " +Name +" section contents").str());

408Expected<const uint8_t *> SecEndPtr = ElfFile.toMappedAddr(EntAddr +Size);

409if (!SecEndPtr)

410return appendToError(

411 SecEndPtr.takeError(),

412 ("when locating " +Name +" section contents").str());

413return *SecPtr;

414 }

415

416constELFFile<ELFT> &ElfFile;

417const DynamicEntries &DynEnt;

418 Elf_Shdr_Range Shdrs;

419const Elf_Shdr *DynSymHdr;

420};

421}// end anonymous namespace

422

423/// This function behaves similarly to StringRef::substr(), but attempts to

424/// terminate the returned StringRef at the first null terminator. If no null

425/// terminator is found, an error is returned.

426///

427/// @param Str Source string to create a substring from.

428/// @param Offset The start index of the desired substring.

429staticExpected<StringRef>terminatedSubstr(StringRef Str,size_tOffset) {

430size_t StrEnd = Str.find('\0',Offset);

431if (StrEnd ==StringLiteral::npos) {

432returncreateError(

433"String overran bounds of string table (no null terminator)");

434 }

435

436size_t StrLen = StrEnd -Offset;

437return Str.substr(Offset, StrLen);

438}

439

440/// This function populates a DynamicEntries struct using an ELFT::DynRange.

441/// After populating the struct, the members are validated with

442/// some basic correctness checks.

443///

444/// @param Dyn Target DynamicEntries struct to populate.

445/// @param DynTable Source dynamic table.

446template <class ELFT>

447staticError populateDynamic(DynamicEntries &Dyn,

448typename ELFT::DynRange DynTable) {

449if (DynTable.empty())

450returncreateError("No .dynamic section found");

451

452// Search .dynamic for relevant entries.

453bool FoundDynStr =false;

454bool FoundDynStrSz =false;

455bool FoundDynSym =false;

456for (auto &Entry : DynTable) {

457switch (Entry.d_tag) {

458case DT_SONAME:

459 Dyn.SONameOffset = Entry.d_un.d_val;

460break;

461case DT_STRTAB:

462 Dyn.StrTabAddr = Entry.d_un.d_ptr;

463 FoundDynStr =true;

464break;

465case DT_STRSZ:

466 Dyn.StrSize = Entry.d_un.d_val;

467 FoundDynStrSz =true;

468break;

469case DT_NEEDED:

470 Dyn.NeededLibNames.push_back(Entry.d_un.d_val);

471break;

472case DT_SYMTAB:

473 Dyn.DynSymAddr = Entry.d_un.d_ptr;

474 FoundDynSym =true;

475break;

476case DT_HASH:

477 Dyn.ElfHash = Entry.d_un.d_ptr;

478break;

479case DT_GNU_HASH:

480 Dyn.GnuHash = Entry.d_un.d_ptr;

481 }

482 }

483

484if (!FoundDynStr) {

485returncreateError(

486"Couldn't locate dynamic string table (no DT_STRTAB entry)");

487 }

488if (!FoundDynStrSz) {

489returncreateError(

490"Couldn't determine dynamic string table size (no DT_STRSZ entry)");

491 }

492if (!FoundDynSym) {

493returncreateError(

494"Couldn't locate dynamic symbol table (no DT_SYMTAB entry)");

495 }

496if (Dyn.SONameOffset && *Dyn.SONameOffset >= Dyn.StrSize) {

497returncreateStringError(object_error::parse_failed,

498"DT_SONAME string offset (0x%016" PRIx64

499") outside of dynamic string table",

500 *Dyn.SONameOffset);

501 }

502for (uint64_t Offset : Dyn.NeededLibNames) {

503if (Offset >= Dyn.StrSize) {

504returncreateStringError(object_error::parse_failed,

505"DT_NEEDED string offset (0x%016" PRIx64

506") outside of dynamic string table",

507Offset);

508 }

509 }

510

511returnError::success();

512}

513

514/// This function creates an IFSSymbol and populates all members using

515/// information from a binary ELFT::Sym.

516///

517/// @param SymName The desired name of the IFSSymbol.

518/// @param RawSym ELFT::Sym to extract symbol information from.

519template <class ELFT>

520staticIFSSymbol createELFSym(StringRef SymName,

521consttypename ELFT::Sym &RawSym) {

522IFSSymbol TargetSym{std::string(SymName)};

523uint8_t Binding = RawSym.getBinding();

524if (Binding ==STB_WEAK)

525 TargetSym.Weak =true;

526else

527 TargetSym.Weak =false;

528

529 TargetSym.Undefined = RawSym.isUndefined();

530 TargetSym.Type =convertELFSymbolTypeToIFS(RawSym.st_info);

531

532if (TargetSym.Type ==IFSSymbolType::Func) {

533 TargetSym.Size = 0;

534 }else {

535 TargetSym.Size = RawSym.st_size;

536 }

537return TargetSym;

538}

539

540/// This function populates an IFSStub with symbols using information read

541/// from an ELF binary.

542///

543/// @param TargetStub IFSStub to add symbols to.

544/// @param DynSym Range of dynamic symbols to add to TargetStub.

545/// @param DynStr StringRef to the dynamic string table.

546template <class ELFT>

547staticError populateSymbols(IFSStub &TargetStub,

548consttypename ELFT::SymRange DynSym,

549StringRef DynStr) {

550// Skips the first symbol since it's the NULL symbol.

551for (auto RawSym : DynSym.drop_front(1)) {

552// If a symbol does not have global or weak binding, ignore it.

553uint8_t Binding = RawSym.getBinding();

554if (!(Binding ==STB_GLOBAL || Binding ==STB_WEAK))

555continue;

556// If a symbol doesn't have default or protected visibility, ignore it.

557uint8_t Visibility = RawSym.getVisibility();

558if (!(Visibility ==STV_DEFAULT || Visibility ==STV_PROTECTED))

559continue;

560// Create an IFSSymbol and populate it with information from the symbol

561// table entry.

562Expected<StringRef> SymName =terminatedSubstr(DynStr, RawSym.st_name);

563if (!SymName)

564return SymName.takeError();

565IFSSymbol Sym = createELFSym<ELFT>(*SymName, RawSym);

566 TargetStub.Symbols.push_back(std::move(Sym));

567// TODO: Populate symbol warning.

568 }

569returnError::success();

570}

571

572/// Returns a new IFSStub with all members populated from an ELFObjectFile.

573/// @param ElfObj Source ELFObjectFile.

574template <class ELFT>

575staticExpected<std::unique_ptr<IFSStub>>

576buildStub(constELFObjectFile<ELFT> &ElfObj) {

577usingElf_Dyn_Range =typename ELFT::DynRange;

578usingElf_Sym_Range =typename ELFT::SymRange;

579usingElf_Sym =typename ELFT::Sym;

580 std::unique_ptr<IFSStub> DestStub = std::make_unique<IFSStub>();

581constELFFile<ELFT> &ElfFile = ElfObj.getELFFile();

582// Fetch .dynamic table.

583Expected<Elf_Dyn_Range> DynTable = ElfFile.dynamicEntries();

584if (!DynTable) {

585return DynTable.takeError();

586 }

587

588// Collect relevant .dynamic entries.

589DynamicEntries DynEnt;

590if (Error Err = populateDynamic<ELFT>(DynEnt, *DynTable))

591return std::move(Err);

592Expected<DynSym<ELFT>> EDynSym = DynSym<ELFT>::create(ElfFile, DynEnt);

593if (!EDynSym)

594return EDynSym.takeError();

595

596Expected<StringRef> EDynStr = EDynSym->getDynStr();

597if (!EDynStr)

598return EDynStr.takeError();

599

600StringRef DynStr = *EDynStr;

601

602// Populate Arch from ELF header.

603 DestStub->Target.Arch =static_cast<IFSArch>(ElfFile.getHeader().e_machine);

604 DestStub->Target.BitWidth =

605convertELFBitWidthToIFS(ElfFile.getHeader().e_ident[EI_CLASS]);

606 DestStub->Target.Endianness =

607convertELFEndiannessToIFS(ElfFile.getHeader().e_ident[EI_DATA]);

608 DestStub->Target.ObjectFormat ="ELF";

609

610// Populate SoName from .dynamic entries and dynamic string table.

611if (DynEnt.SONameOffset) {

612Expected<StringRef> NameOrErr =

613terminatedSubstr(DynStr, *DynEnt.SONameOffset);

614if (!NameOrErr) {

615return appendToError(NameOrErr.takeError(),"when reading DT_SONAME");

616 }

617 DestStub->SoName = std::string(*NameOrErr);

618 }

619

620// Populate NeededLibs from .dynamic entries and dynamic string table.

621for (uint64_t NeededStrOffset : DynEnt.NeededLibNames) {

622Expected<StringRef> LibNameOrErr =

623terminatedSubstr(DynStr, NeededStrOffset);

624if (!LibNameOrErr) {

625return appendToError(LibNameOrErr.takeError(),"when reading DT_NEEDED");

626 }

627 DestStub->NeededLibs.push_back(std::string(*LibNameOrErr));

628 }

629

630// Populate Symbols from .dynsym table and dynamic string table.

631Expected<uint64_t> SymCount = ElfFile.getDynSymtabSize();

632if (!SymCount)

633return SymCount.takeError();

634if (*SymCount > 0) {

635// Get pointer to in-memory location of .dynsym section.

636Expected<const uint8_t *> DynSymPtr = EDynSym->getDynSym();

637if (!DynSymPtr)

638return appendToError(DynSymPtr.takeError(),

639"when locating .dynsym section contents");

640 Elf_Sym_Range DynSyms =ArrayRef<Elf_Sym>(

641reinterpret_cast<constElf_Sym *>(*DynSymPtr), *SymCount);

642Error SymReadError = populateSymbols<ELFT>(*DestStub, DynSyms, DynStr);

643if (SymReadError)

644return appendToError(std::move(SymReadError),

645"when reading dynamic symbols");

646 }

647

648return std::move(DestStub);

649}

650

651/// This function opens a file for writing and then writes a binary ELF stub to

652/// the file.

653///

654/// @param FilePath File path for writing the ELF binary.

655/// @param Stub Source InterFace Stub to generate a binary ELF stub from.

656template <class ELFT>

657staticError writeELFBinaryToFile(StringRef FilePath,constIFSStub &Stub,

658boolWriteIfChanged) {

659 ELFStubBuilder<ELFT> Builder{Stub};

660// Write Stub to memory first.

661 std::vector<uint8_t> Buf(Builder.getSize());

662 Builder.write(Buf.data());

663

664if (WriteIfChanged) {

665if (ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =

666MemoryBuffer::getFile(FilePath)) {

667// Compare Stub output with existing Stub file.

668// If Stub file unchanged, abort updating.

669if ((*BufOrError)->getBufferSize() == Builder.getSize() &&

670 !memcmp((*BufOrError)->getBufferStart(), Buf.data(),

671 Builder.getSize()))

672returnError::success();

673 }

674 }

675

676Expected<std::unique_ptr<FileOutputBuffer>> BufOrError =

677FileOutputBuffer::create(FilePath, Builder.getSize());

678if (!BufOrError)

679returncreateStringError(errc::invalid_argument,

680toString(BufOrError.takeError()) +

681" when trying to open `" + FilePath +

682"` for writing");

683

684// Write binary to file.

685 std::unique_ptr<FileOutputBuffer> FileBuf = std::move(*BufOrError);

686 memcpy(FileBuf->getBufferStart(), Buf.data(), Buf.size());

687

688return FileBuf->commit();

689}

690

691Expected<std::unique_ptr<IFSStub>>readELFFile(MemoryBufferRef Buf) {

692Expected<std::unique_ptr<Binary>> BinOrErr =createBinary(Buf);

693if (!BinOrErr) {

694return BinOrErr.takeError();

695 }

696

697Binary *Bin = BinOrErr->get();

698if (auto Obj =dyn_cast<ELFObjectFile<ELF32LE>>(Bin)) {

699returnbuildStub(*Obj);

700 }elseif (auto Obj =dyn_cast<ELFObjectFile<ELF64LE>>(Bin)) {

701returnbuildStub(*Obj);

702 }elseif (auto Obj =dyn_cast<ELFObjectFile<ELF32BE>>(Bin)) {

703returnbuildStub(*Obj);

704 }elseif (auto Obj =dyn_cast<ELFObjectFile<ELF64BE>>(Bin)) {

705returnbuildStub(*Obj);

706 }

707returncreateStringError(errc::not_supported,"unsupported binary format");

708}

709

710// This function wraps the ELFT writeELFBinaryToFile() so writeBinaryStub()

711// can be called without having to use ELFType templates directly.

712Error writeBinaryStub(StringRef FilePath,constIFSStub &Stub,

713boolWriteIfChanged) {

714assert(Stub.Target.Arch);

715assert(Stub.Target.BitWidth);

716assert(Stub.Target.Endianness);

717if (Stub.Target.BitWidth ==IFSBitWidthType::IFS32) {

718if (Stub.Target.Endianness ==IFSEndiannessType::Little) {

719return writeELFBinaryToFile<ELF32LE>(FilePath, Stub,WriteIfChanged);

720 }else {

721return writeELFBinaryToFile<ELF32BE>(FilePath, Stub,WriteIfChanged);

722 }

723 }else {

724if (Stub.Target.Endianness ==IFSEndiannessType::Little) {

725return writeELFBinaryToFile<ELF64LE>(FilePath, Stub,WriteIfChanged);

726 }else {

727return writeELFBinaryToFile<ELF64BE>(FilePath, Stub,WriteIfChanged);

728 }

729 }

730llvm_unreachable("invalid binary output target");

731}

732

733}// end namespace ifs

734}// end namespace llvm

Binary.h

Machine

COFF::MachineTypes Machine

Definition:COFFYAML.cpp:390

Content

T Content

Definition:ELFObjHandler.cpp:89

Shdr

Elf_Shdr Shdr

Definition:ELFObjHandler.cpp:78

NoBits

bool NoBits

Definition:ELFObjHandler.cpp:84

Addr

uint64_t Addr

Definition:ELFObjHandler.cpp:79

Name

std::string Name

Definition:ELFObjHandler.cpp:77

Size

uint64_t Size

Definition:ELFObjHandler.cpp:81

ELFObjHandler.h

This supports reading and writing of elf dynamic shared objects.

ELFObjectFile.h

ELFTypes.h

Sym

Symbol * Sym

Definition:ELF_riscv.cpp:479

Errc.h

FileOutputBuffer.h

IFSStub.h

This file defines an internal representation of an InterFace Stub.

WriteIfChanged

static cl::opt< bool > WriteIfChanged("write-if-changed", cl::desc("Only write output if it changed"))

MathExtras.h

MemoryBuffer.h

memcmp

Merge contiguous icmps into a memcmp

Definition:MergeICmps.cpp:911

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

IRDumpFileSuffixType::After

@ After

StringTableBuilder.h

getSize

static unsigned getSize(unsigned Kind)

Definition:XtensaAsmBackend.cpp:134

llvm::ArrayRef

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Definition:ArrayRef.h:41

llvm::ErrorOr

Represents either an error or a value T.

Definition:ErrorOr.h:56

llvm::Error

Lightweight error class with error context and mandatory checking.

Definition:Error.h:160

llvm::Error::success

static ErrorSuccess success()

Create a success value.

Definition:Error.h:337

llvm::Expected

Tagged union holding either a T or a Error.

Definition:Error.h:481

llvm::Expected::takeError

Error takeError()

Take ownership of the stored error.

Definition:Error.h:608

llvm::Expected::get

reference get()

Returns a reference to the stored T value.

Definition:Error.h:578

llvm::FileOutputBuffer::create

static Expected< std::unique_ptr< FileOutputBuffer > > create(StringRef FilePath, size_t Size, unsigned Flags=0)

Factory method to create an OutputBuffer object which manages a read/write buffer of the specified si...

Definition:FileOutputBuffer.cpp:159

llvm::MemoryBufferRef

Definition:MemoryBufferRef.h:22

llvm::MemoryBuffer::getFile

static ErrorOr< std::unique_ptr< MemoryBuffer > > getFile(const Twine &Filename, bool IsText=false, bool RequiresNullTerminator=true, bool IsVolatile=false, std::optional< Align > Alignment=std::nullopt)

Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...

Definition:MemoryBuffer.cpp:260

llvm::SmallVector

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Definition:SmallVector.h:1196

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::StringRef::npos

static constexpr size_t npos

Definition:StringRef.h:53

llvm::StringTableBuilder

Utility for building string tables with deduplicated suffixes.

Definition:StringTableBuilder.h:24

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::object::Binary

Definition:Binary.h:32

llvm::object::ELFFile

Definition:ELF.h:255

llvm::object::ELFObjectFile

Definition:ELFObjectFile.h:265

llvm::object::ELFObjectFile::getELFFile

const ELFFile< ELFT > & getELFFile() const

Definition:ELFObjectFile.h:496

llvm::raw_string_ostream

A raw_ostream that writes to an std::string.

Definition:raw_ostream.h:661

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Definition:ErrorHandling.h:143

Error.h

llvm::ARM_AM::add

@ add

Definition:ARMAddressingModes.h:39

llvm::COFF::Entry

@ Entry

Definition:COFF.h:844

llvm::ELF

Definition:ELF.h:28

llvm::ELF::ELFOSABI_NONE

@ ELFOSABI_NONE

Definition:ELF.h:344

llvm::ELF::SHN_UNDEF

@ SHN_UNDEF

Definition:ELF.h:1083

llvm::ELF::ELFCLASS64

@ ELFCLASS64

Definition:ELF.h:332

llvm::ELF::ELFCLASS32

@ ELFCLASS32

Definition:ELF.h:331

llvm::ELF::EI_DATA

@ EI_DATA

Definition:ELF.h:54

llvm::ELF::EI_MAG3

@ EI_MAG3

Definition:ELF.h:52

llvm::ELF::EI_MAG1

@ EI_MAG1

Definition:ELF.h:50

llvm::ELF::EI_VERSION

@ EI_VERSION

Definition:ELF.h:55

llvm::ELF::EI_MAG2

@ EI_MAG2

Definition:ELF.h:51

llvm::ELF::EI_MAG0

@ EI_MAG0

Definition:ELF.h:49

llvm::ELF::EI_CLASS

@ EI_CLASS

Definition:ELF.h:53

llvm::ELF::EI_OSABI

@ EI_OSABI

Definition:ELF.h:56

llvm::ELF::EV_CURRENT

@ EV_CURRENT

Definition:ELF.h:128

llvm::ELF::ElfMagic

static const char ElfMagic[]

Definition:ELF.h:45

llvm::ELF::SHT_STRTAB

@ SHT_STRTAB

Definition:ELF.h:1100

llvm::ELF::SHT_DYNAMIC

@ SHT_DYNAMIC

Definition:ELF.h:1103

llvm::ELF::SHT_DYNSYM

@ SHT_DYNSYM

Definition:ELF.h:1108

llvm::ELF::SHF_ALLOC

@ SHF_ALLOC

Definition:ELF.h:1198

llvm::ELF::STB_GLOBAL

@ STB_GLOBAL

Definition:ELF.h:1352

llvm::ELF::STB_WEAK

@ STB_WEAK

Definition:ELF.h:1353

llvm::ELF::ET_DYN

@ ET_DYN

Definition:ELF.h:119

llvm::ELF::ELFDATA2MSB

@ ELFDATA2MSB

Definition:ELF.h:339

llvm::ELF::ELFDATA2LSB

@ ELFDATA2LSB

Definition:ELF.h:338

llvm::ELF::STV_PROTECTED

@ STV_PROTECTED

Definition:ELF.h:1384

llvm::ELF::STV_DEFAULT

@ STV_DEFAULT

Definition:ELF.h:1381

llvm::dwarf::Index

Index

Definition:Dwarf.h:882

llvm::ifs::writeELFBinaryToFile

static Error writeELFBinaryToFile(StringRef FilePath, const IFSStub &Stub, bool WriteIfChanged)

This function opens a file for writing and then writes a binary ELF stub to the file.

Definition:ELFObjHandler.cpp:657

llvm::ifs::readELFFile

Expected< std::unique_ptr< IFSStub > > readELFFile(MemoryBufferRef Buf)

Attempt to read a binary ELF file from a MemoryBuffer.

Definition:ELFObjHandler.cpp:691

llvm::ifs::writeBinaryStub

Error writeBinaryStub(StringRef FilePath, const IFSStub &Stub, bool WriteIfChanged=false)

Attempt to write a binary ELF stub.

Definition:ELFObjHandler.cpp:712

llvm::ifs::convertIFSSymbolTypeToELF

uint8_t convertIFSSymbolTypeToELF(IFSSymbolType SymbolType)

This function convert symbol type from IFS enum to ELF format Currently, STT_NOTYPE,...

Definition:IFSStub.cpp:83

llvm::ifs::IFSEndiannessType::Little

@ Little

llvm::ifs::IFSBitWidthType::IFS32

@ IFS32

llvm::ifs::buildStub

static Expected< std::unique_ptr< IFSStub > > buildStub(const ELFObjectFile< ELFT > &ElfObj)

Returns a new IFSStub with all members populated from an ELFObjectFile.

Definition:ELFObjHandler.cpp:576

llvm::ifs::IFSSymbolType::Func

@ Func

llvm::ifs::populateSymbols

static Error populateSymbols(IFSStub &TargetStub, const typename ELFT::SymRange DynSym, StringRef DynStr)

This function populates an IFSStub with symbols using information read from an ELF binary.

Definition:ELFObjHandler.cpp:547

llvm::ifs::initELFHeader

static void initELFHeader(typename ELFT::Ehdr &ElfHeader, uint16_t Machine)

This initializes an ELF file header with information specific to a binary dynamic shared object.

Definition:ELFObjHandler.cpp:52

llvm::ifs::convertELFBitWidthToIFS

IFSBitWidthType convertELFBitWidthToIFS(uint8_t BitWidth)

This function extracts ELF bit width from e_ident[EI_CLASS] of an ELF file Currently,...

Definition:IFSStub.cpp:98

llvm::ifs::convertELFEndiannessToIFS

IFSEndiannessType convertELFEndiannessToIFS(uint8_t Endianness)

This function extracts ELF endianness from e_ident[EI_DATA] of an ELF file Currently,...

Definition:IFSStub.cpp:109

llvm::ifs::populateDynamic

static Error populateDynamic(DynamicEntries &Dyn, typename ELFT::DynRange DynTable)

This function populates a DynamicEntries struct using an ELFT::DynRange.

Definition:ELFObjHandler.cpp:447

llvm::ifs::createELFSym

static IFSSymbol createELFSym(StringRef SymName, const typename ELFT::Sym &RawSym)

This function creates an IFSSymbol and populates all members using information from a binary ELFT::Sy...

Definition:ELFObjHandler.cpp:520

llvm::ifs::convertELFSymbolTypeToIFS

IFSSymbolType convertELFSymbolTypeToIFS(uint8_t SymbolType)

This function extracts symbol type from a symbol's st_info member and maps it to an IFSSymbolType enu...

Definition:IFSStub.cpp:120

llvm::ifs::terminatedSubstr

static Expected< StringRef > terminatedSubstr(StringRef Str, size_t Offset)

This function behaves similarly to StringRef::substr(), but attempts to terminate the returned String...

Definition:ELFObjHandler.cpp:429

llvm::logicalview::LVBinaryType::ELF

@ ELF

llvm::object

Definition:DWARFDebugLoc.h:24

llvm::object::createBinary

Expected< std::unique_ptr< Binary > > createBinary(MemoryBufferRef Source, LLVMContext *Context=nullptr, bool InitContent=true)

Create a Binary from Source, autodetecting the file type.

Definition:Binary.cpp:45

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::Offset

@ Offset

Definition:DWP.cpp:480

llvm::dyn_cast

decltype(auto) dyn_cast(const From &Val)

dyn_cast<X> - Return the argument parameter cast to the specified type.

Definition:Casting.h:649

llvm::SubDirectoryType::Lib

@ Lib

llvm::SubDirectoryType::Bin

@ Bin

llvm::createStringError

Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)

Create formatted StringError object.

Definition:Error.h:1291

llvm::errc::not_supported

@ not_supported

llvm::errc::invalid_argument

@ invalid_argument

llvm::write

Error write(MCStreamer &Out, ArrayRef< std::string > Inputs, OnCuIndexOverflow OverflowOptValue)

Definition:DWP.cpp:625

llvm::createError

static Error createError(const Twine &Err)

Definition:APFloat.cpp:397

llvm::alignTo

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

Definition:Alignment.h:155

llvm::HighlightColor::Tag

@ Tag

llvm::toString

const char * toString(DWARFSectionKind Kind)

Definition:DWARFUnitIndex.h:67

llvm::endianness::little

@ little

llvm::Data

@ Data

Definition:SIMachineScheduler.h:55

llvm::consumeError

void consumeError(Error Err)

Consume a Error without doing anything.

Definition:Error.h:1069

llvm::Align

This struct is a compact representation of a valid (non-zero power of two) alignment.

Definition:Alignment.h:39

llvm::ifs::DynamicEntries

Definition:ELFObjHandler.cpp:32

llvm::ifs::DynamicEntries::ElfHash

std::optional< uint64_t > ElfHash

Definition:ELFObjHandler.cpp:40

llvm::ifs::DynamicEntries::NeededLibNames

std::vector< uint64_t > NeededLibNames

Definition:ELFObjHandler.cpp:36

llvm::ifs::DynamicEntries::GnuHash

std::optional< uint64_t > GnuHash

Definition:ELFObjHandler.cpp:41

llvm::ifs::DynamicEntries::StrTabAddr

uint64_t StrTabAddr

Definition:ELFObjHandler.cpp:33

llvm::ifs::DynamicEntries::SONameOffset

std::optional< uint64_t > SONameOffset

Definition:ELFObjHandler.cpp:35

llvm::ifs::DynamicEntries::StrSize

uint64_t StrSize

Definition:ELFObjHandler.cpp:34

llvm::ifs::DynamicEntries::DynSymAddr

uint64_t DynSymAddr

Definition:ELFObjHandler.cpp:38

llvm::ifs::IFSStub

Definition:IFSStub.h:89

llvm::ifs::IFSStub::Symbols

std::vector< IFSSymbol > Symbols

Definition:IFSStub.h:95

llvm::ifs::IFSStub::Target

IFSTarget Target

Definition:IFSStub.h:93

llvm::ifs::IFSSymbol

Definition:IFSStub.h:52

llvm::ifs::IFSTarget::Endianness

std::optional< IFSEndiannessType > Endianness

Definition:IFSStub.h:69

llvm::ifs::IFSTarget::BitWidth

std::optional< IFSBitWidthType > BitWidth

Definition:IFSStub.h:70

llvm::ifs::IFSTarget::Arch

std::optional< IFSArch > Arch

Definition:IFSStub.h:67