llvm-objdump.h

//===--- llvm-objdump.h -----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_TOOLS_LLVM_OBJDUMP_LLVM_OBJDUMP_H
#defineLLVM_TOOLS_LLVM_OBJDUMP_LLVM_OBJDUMP_H

#include"llvm/ADT/StringSet.h"
#include"llvm/DebugInfo/DIContext.h"
#include"llvm/MC/MCDisassembler/MCDisassembler.h"
#include"llvm/Object/Archive.h"
#include"llvm/Support/Compiler.h"
#include"llvm/Support/DataTypes.h"

namespacellvm {
classStringRef;
classTwine;

namespaceobject {
classRelocationRef;
structVersionEntry;
} // namespace object

namespaceobjdump {

enum DebugVarsFormat { DVDisabled, DVUnicode, DVASCII, DVInvalid };

externbool ArchiveHeaders;
externint DbgIndent;
extern DebugVarsFormat DbgVariables;
externbool Demangle;
externbool Disassemble;
externbool DisassembleAll;
extern DIDumpType DwarfDumpType;
extern std::vector<std::string> FilterSections;
externbool LeadingAddr;
extern std::vector<std::string> MAttrs;
extern std::string MCPU;
extern std::string Prefix;
externuint32_t PrefixStrip;
externbool PrintImmHex;
externbool PrintLines;
externbool PrintSource;
externbool PrivateHeaders;
externbool Relocations;
externbool SectionHeaders;
externbool SectionContents;
externbool ShowRawInsn;
externbool SymbolDescription;
externbool SymbolTable;
extern std::string TripleName;
externbool UnwindInfo;

extern StringSet<> FoundSectionSet;

typedef std::function<bool(llvm::object::SectionRef const &)> FilterPredicate;

/// A filtered iterator for SectionRefs that skips sections based on some given
/// predicate.
classSectionFilterIterator {
public:
SectionFilterIterator(FilterPredicate P,
 llvm::object::section_iterator const &I,
 llvm::object::section_iterator const &E)
 : Predicate(std::move(P)), Iterator(I), End(E) {
ScanPredicate();
 }
const llvm::object::SectionRef &operator*() const { return *Iterator; }
 SectionFilterIterator &operator++() {
 ++Iterator;
ScanPredicate();
return *this;
 }
booloperator!=(SectionFilterIterator const &Other) const {
return Iterator != Other.Iterator;
 }

private:
voidScanPredicate() {
while (Iterator != End && !Predicate(*Iterator)) {
 ++Iterator;
 }
 }
 FilterPredicate Predicate;
 llvm::object::section_iterator Iterator;
 llvm::object::section_iterator End;
};

/// Creates an iterator range of SectionFilterIterators for a given Object and
/// predicate.
classSectionFilter {
public:
SectionFilter(FilterPredicate P, llvm::object::ObjectFile const &O)
 : Predicate(std::move(P)), Object(O) {}
 SectionFilterIterator begin() {
returnSectionFilterIterator(Predicate, Object.section_begin(),
 Object.section_end());
 }
 SectionFilterIterator end() {
returnSectionFilterIterator(Predicate, Object.section_end(),
 Object.section_end());
 }

private:
 FilterPredicate Predicate;
 llvm::object::ObjectFile const &Object;
};

// Various helper functions.

/// Creates a SectionFilter with a standard predicate that conditionally skips
/// sections when the --section objdump flag is provided.
///
/// Idx is an optional output parameter that keeps track of which section index
/// this is. This may be different than the actual section number, as some
/// sections may be filtered (e.g. symbol tables).
SectionFilter ToolSectionFilter(llvm::object::ObjectFile const &O,
uint64_t *Idx = nullptr);

boolisRelocAddressLess(object::RelocationRef A, object::RelocationRef B);
voidprintRelocations(const object::ObjectFile *O);
voidprintDynamicRelocations(const object::ObjectFile *O);
voidprintSectionHeaders(object::ObjectFile &O);
voidprintSectionContents(const object::ObjectFile *O);
voidprintSymbolTable(const object::ObjectFile &O, StringRef ArchiveName,
 StringRef ArchitectureName = StringRef(),
 bool DumpDynamic = false);
voidprintSymbol(const object::ObjectFile &O, const object::SymbolRef &Symbol,
 ArrayRef<object::VersionEntry> SymbolVersions,
 StringRef FileName, StringRef ArchiveName,
 StringRef ArchitectureName, bool DumpDynamic);
[[noreturn]] voidreportError(StringRef File, const Twine &Message);
[[noreturn]] voidreportError(Error E, StringRef FileName,
 StringRef ArchiveName = "",
 StringRef ArchitectureName = "");
voidreportWarning(const Twine &Message, StringRef File);

template <typename T, typename... Ts>
T unwrapOrError(Expected<T> EO, Ts &&... Args) {
if (EO)
returnstd::move(*EO);
reportError(EO.takeError(), std::forward<Ts>(Args)...);
}

std::string getFileNameForError(const object::Archive::Child &C,
unsigned Index);
SymbolInfoTy createSymbolInfo(const object::ObjectFile &Obj,
const object::SymbolRef &Symbol);

} // namespace objdump
} // end namespace llvm

#endif