#define LLVM_OBJECT_MACHO_H
#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
+#include "llvm/MC/SubtargetFeature.h"
+#include "llvm/Object/Binary.h"
#include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/Format.h"
#include "llvm/Support/MachO.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <system_error>
namespace llvm {
namespace object {
/// data in code entry in the table in a Mach-O object file.
class DiceRef {
DataRefImpl DicePimpl;
- const ObjectFile *OwningObject;
+ const ObjectFile *OwningObject = nullptr;
public:
- DiceRef() : OwningObject(nullptr) { }
-
+ DiceRef() = default;
DiceRef(DataRefImpl DiceP, const ObjectFile *Owner);
bool operator==(const DiceRef &Other) const;
DataRefImpl getRawDataRefImpl() const;
const ObjectFile *getObjectFile() const;
};
-typedef content_iterator<DiceRef> dice_iterator;
+using dice_iterator = content_iterator<DiceRef>;
/// ExportEntry encapsulates the current-state-of-the-walk used when doing a
/// non-recursive walk of the trie data structure. This allows you to iterate
private:
friend class MachOObjectFile;
+
void moveToFirst();
void moveToEnd();
uint64_t readULEB128(const uint8_t *&p);
// Represents a node in the mach-o exports trie.
struct NodeState {
NodeState(const uint8_t *Ptr);
+
const uint8_t *Start;
const uint8_t *Current;
- uint64_t Flags;
- uint64_t Address;
- uint64_t Other;
- const char *ImportName;
- unsigned ChildCount;
- unsigned NextChildIndex;
- unsigned ParentStringLength;
- bool IsExportNode;
+ uint64_t Flags = 0;
+ uint64_t Address = 0;
+ uint64_t Other = 0;
+ const char *ImportName = nullptr;
+ unsigned ChildCount = 0;
+ unsigned NextChildIndex = 0;
+ unsigned ParentStringLength = 0;
+ bool IsExportNode = false;
};
ArrayRef<uint8_t> Trie;
SmallString<256> CumulativeString;
SmallVector<NodeState, 16> Stack;
- bool Malformed;
- bool Done;
+ bool Malformed = false;
+ bool Done = false;
};
-typedef content_iterator<ExportEntry> export_iterator;
+using export_iterator = content_iterator<ExportEntry>;
// Segment info so SegIndex/SegOffset pairs in a Mach-O Bind or Rebase entry
// can be checked and translated. Only the SegIndex/SegOffset pairs from
// address() methods below.
class BindRebaseSegInfo {
public:
- BindRebaseSegInfo(const object::MachOObjectFile *Obj);
+ BindRebaseSegInfo(const MachOObjectFile *Obj);
// Used to check a Mach-O Bind or Rebase entry for errors when iterating.
const char *checkSegAndOffset(int32_t SegIndex, uint64_t SegOffset,
int32_t SegmentIndex;
};
const SectionInfo &findSection(int32_t SegIndex, uint64_t SegOffset);
+
SmallVector<SectionInfo, 32> Sections;
int32_t MaxSegIndex;
};
private:
friend class MachOObjectFile;
+
void moveToFirst();
void moveToEnd();
uint64_t readULEB128(const char **error);
const MachOObjectFile *O;
ArrayRef<uint8_t> Opcodes;
const uint8_t *Ptr;
- uint64_t SegmentOffset;
- int32_t SegmentIndex;
- uint64_t RemainingLoopCount;
- uint64_t AdvanceAmount;
- uint8_t RebaseType;
+ uint64_t SegmentOffset = 0;
+ int32_t SegmentIndex = -1;
+ uint64_t RemainingLoopCount = 0;
+ uint64_t AdvanceAmount = 0;
+ uint8_t RebaseType = 0;
uint8_t PointerSize;
- bool Done;
+ bool Done = false;
};
-typedef content_iterator<MachORebaseEntry> rebase_iterator;
+using rebase_iterator = content_iterator<MachORebaseEntry>;
/// MachOBindEntry encapsulates the current state in the decompression of
/// binding opcodes. This allows you to iterate through the compressed table of
private:
friend class MachOObjectFile;
+
void moveToFirst();
void moveToEnd();
uint64_t readULEB128(const char **error);
const MachOObjectFile *O;
ArrayRef<uint8_t> Opcodes;
const uint8_t *Ptr;
- uint64_t SegmentOffset;
- int32_t SegmentIndex;
+ uint64_t SegmentOffset = 0;
+ int32_t SegmentIndex = -1;
StringRef SymbolName;
- bool LibraryOrdinalSet;
- int Ordinal;
- uint32_t Flags;
- int64_t Addend;
- uint64_t RemainingLoopCount;
- uint64_t AdvanceAmount;
- uint8_t BindType;
+ bool LibraryOrdinalSet = false;
+ int Ordinal = 0;
+ uint32_t Flags = 0;
+ int64_t Addend = 0;
+ uint64_t RemainingLoopCount = 0;
+ uint64_t AdvanceAmount = 0;
+ uint8_t BindType = 0;
uint8_t PointerSize;
Kind TableKind;
- bool Done;
+ bool Done = false;
};
-typedef content_iterator<MachOBindEntry> bind_iterator;
+using bind_iterator = content_iterator<MachOBindEntry>;
class MachOObjectFile : public ObjectFile {
public:
const char *Ptr; // Where in memory the load command is.
MachO::load_command C; // The command itself.
};
- typedef SmallVector<LoadCommandInfo, 4> LoadCommandList;
- typedef LoadCommandList::const_iterator load_command_iterator;
+ using LoadCommandList = SmallVector<LoadCommandInfo, 4>;
+ using load_command_iterator = LoadCommandList::const_iterator;
static Expected<std::unique_ptr<MachOObjectFile>>
create(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
case MachO::PLATFORM_BRIDGEOS: return "bridgeos";
default:
std::string ret;
- llvm::raw_string_ostream ss(ret);
+ raw_string_ostream ss(ret);
ss << format_hex(platform, 8, true);
return ss.str();
}
case MachO::TOOL_LD: return "ld";
default:
std::string ret;
- llvm::raw_string_ostream ss(ret);
+ raw_string_ostream ss(ret);
ss << format_hex(tools, 8, true);
return ss.str();
}
}
private:
-
MachOObjectFile(MemoryBufferRef Object, bool IsLittleEndian, bool Is64Bits,
Error &Err, uint32_t UniversalCputype = 0,
uint32_t UniversalIndex = 0);
MachO::mach_header_64 Header64;
MachO::mach_header Header;
};
- typedef SmallVector<const char*, 1> SectionList;
+ using SectionList = SmallVector<const char*, 1>;
SectionList Sections;
- typedef SmallVector<const char*, 1> LibraryList;
+ using LibraryList = SmallVector<const char*, 1>;
LibraryList Libraries;
LoadCommandList LoadCommands;
- typedef SmallVector<StringRef, 1> LibraryShortName;
+ using LibraryShortName = SmallVector<StringRef, 1>;
using BuildToolList = SmallVector<const char*, 1>;
BuildToolList BuildTools;
mutable LibraryShortName LibrariesShortNames;
std::unique_ptr<BindRebaseSegInfo> BindRebaseSectionTable;
- const char *SymtabLoadCmd;
- const char *DysymtabLoadCmd;
- const char *DataInCodeLoadCmd;
- const char *LinkOptHintsLoadCmd;
- const char *DyldInfoLoadCmd;
- const char *UuidLoadCmd;
- bool HasPageZeroSegment;
+ const char *SymtabLoadCmd = nullptr;
+ const char *DysymtabLoadCmd = nullptr;
+ const char *DataInCodeLoadCmd = nullptr;
+ const char *LinkOptHintsLoadCmd = nullptr;
+ const char *DyldInfoLoadCmd = nullptr;
+ const char *UuidLoadCmd = nullptr;
+ bool HasPageZeroSegment = false;
};
/// DiceRef
return OwningObject;
}
-}
-}
+} // end namespace object
+} // end namespace llvm
-#endif
+#endif // LLVM_OBJECT_MACHO_H
-//===- ModuleSummaryIndexObjectFile.h - Summary index file implementation -=//
+//===- ModuleSummaryIndexObjectFile.h - Summary index file implementation -===//
//
// The LLVM Compiler Infrastructure
//
#ifndef LLVM_OBJECT_MODULESUMMARYINDEXOBJECTFILE_H
#define LLVM_OBJECT_MODULESUMMARYINDEXOBJECTFILE_H
-#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Object/Binary.h"
#include "llvm/Object/SymbolicFile.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include <memory>
+#include <system_error>
namespace llvm {
+
class ModuleSummaryIndex;
-class Module;
namespace object {
+
class ObjectFile;
/// This class is used to read just the module summary index related
void moveSymbolNext(DataRefImpl &Symb) const override {
llvm_unreachable("not implemented");
}
+
std::error_code printSymbolName(raw_ostream &OS,
DataRefImpl Symb) const override {
llvm_unreachable("not implemented");
return std::error_code();
}
+
uint32_t getSymbolFlags(DataRefImpl Symb) const override {
llvm_unreachable("not implemented");
return 0;
}
+
basic_symbol_iterator symbol_begin() const override {
llvm_unreachable("not implemented");
return basic_symbol_iterator(BasicSymbolRef());
static Expected<std::unique_ptr<ModuleSummaryIndexObjectFile>>
create(MemoryBufferRef Object);
};
-}
+
+} // end namespace object
/// Parse the module summary index out of an IR file and return the module
/// summary index object if found, or nullptr if not. If Identifier is
/// containing minimized bitcode just for the thin link.
Expected<std::unique_ptr<ModuleSummaryIndex>>
getModuleSummaryIndexForFile(StringRef Path, StringRef Identifier = "");
-}
-#endif
+} // end namespace llvm
+
+#endif // LLVM_OBJECT_MODULESUMMARYINDEXOBJECTFILE_H
-//===-- RelocVisitor.h - Visitor for object file relocations -*- C++ -*-===//
+//===- RelocVisitor.h - Visitor for object file relocations -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#ifndef LLVM_OBJECT_RELOCVISITOR_H
#define LLVM_OBJECT_RELOCVISITOR_H
+#include "llvm/ADT/Triple.h"
#include "llvm/Object/COFF.h"
#include "llvm/Object/ELFObjectFile.h"
#include "llvm/Object/MachO.h"
#include "llvm/Object/ObjectFile.h"
-#include "llvm/Support/Debug.h"
+#include "llvm/Support/Casting.h"
#include "llvm/Support/ELF.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/MachO.h"
-#include "llvm/Support/raw_ostream.h"
+#include <cstdint>
+#include <system_error>
namespace llvm {
namespace object {
struct RelocToApply {
// The computed value after applying the relevant relocations.
- int64_t Value;
+ int64_t Value = 0;
// The width of the value; how many bytes to touch when applying the
// relocation.
- char Width;
+ char Width = 0;
+
+ RelocToApply() = default;
RelocToApply(int64_t Value, char Width) : Value(Value), Width(Width) {}
- RelocToApply() : Value(0), Width(0) {}
};
/// @brief Base class for object file relocation visitors.
class RelocVisitor {
public:
- explicit RelocVisitor(const ObjectFile &Obj)
- : ObjToVisit(Obj), HasError(false) {}
+ explicit RelocVisitor(const ObjectFile &Obj) : ObjToVisit(Obj) {}
// TODO: Should handle multiple applied relocations via either passing in the
// previously computed value or just count paired relocations as a single
private:
const ObjectFile &ObjToVisit;
- bool HasError;
+ bool HasError = false;
RelocToApply visitELF(uint32_t RelocType, RelocationRef R, uint64_t Value) {
if (ObjToVisit.getBytesInAddress() == 8) { // 64-bit object file
switch (ObjToVisit.getArch()) {
case Triple::x86_64:
switch (RelocType) {
- case llvm::ELF::R_X86_64_NONE:
+ case ELF::R_X86_64_NONE:
return visitELF_X86_64_NONE(R);
- case llvm::ELF::R_X86_64_64:
+ case ELF::R_X86_64_64:
return visitELF_X86_64_64(R, Value);
- case llvm::ELF::R_X86_64_PC32:
+ case ELF::R_X86_64_PC32:
return visitELF_X86_64_PC32(R, Value);
- case llvm::ELF::R_X86_64_32:
+ case ELF::R_X86_64_32:
return visitELF_X86_64_32(R, Value);
- case llvm::ELF::R_X86_64_32S:
+ case ELF::R_X86_64_32S:
return visitELF_X86_64_32S(R, Value);
default:
HasError = true;
case Triple::aarch64:
case Triple::aarch64_be:
switch (RelocType) {
- case llvm::ELF::R_AARCH64_ABS32:
+ case ELF::R_AARCH64_ABS32:
return visitELF_AARCH64_ABS32(R, Value);
- case llvm::ELF::R_AARCH64_ABS64:
+ case ELF::R_AARCH64_ABS64:
return visitELF_AARCH64_ABS64(R, Value);
default:
HasError = true;
case Triple::bpfel:
case Triple::bpfeb:
switch (RelocType) {
- case llvm::ELF::R_BPF_64_64:
+ case ELF::R_BPF_64_64:
return visitELF_BPF_64_64(R, Value);
- case llvm::ELF::R_BPF_64_32:
+ case ELF::R_BPF_64_32:
return visitELF_BPF_64_32(R, Value);
default:
HasError = true;
case Triple::mips64el:
case Triple::mips64:
switch (RelocType) {
- case llvm::ELF::R_MIPS_32:
+ case ELF::R_MIPS_32:
return visitELF_MIPS64_32(R, Value);
- case llvm::ELF::R_MIPS_64:
+ case ELF::R_MIPS_64:
return visitELF_MIPS64_64(R, Value);
default:
HasError = true;
case Triple::ppc64le:
case Triple::ppc64:
switch (RelocType) {
- case llvm::ELF::R_PPC64_ADDR32:
+ case ELF::R_PPC64_ADDR32:
return visitELF_PPC64_ADDR32(R, Value);
- case llvm::ELF::R_PPC64_ADDR64:
+ case ELF::R_PPC64_ADDR64:
return visitELF_PPC64_ADDR64(R, Value);
default:
HasError = true;
}
case Triple::systemz:
switch (RelocType) {
- case llvm::ELF::R_390_32:
+ case ELF::R_390_32:
return visitELF_390_32(R, Value);
- case llvm::ELF::R_390_64:
+ case ELF::R_390_64:
return visitELF_390_64(R, Value);
default:
HasError = true;
}
case Triple::sparcv9:
switch (RelocType) {
- case llvm::ELF::R_SPARC_32:
- case llvm::ELF::R_SPARC_UA32:
+ case ELF::R_SPARC_32:
+ case ELF::R_SPARC_UA32:
return visitELF_SPARCV9_32(R, Value);
- case llvm::ELF::R_SPARC_64:
- case llvm::ELF::R_SPARC_UA64:
+ case ELF::R_SPARC_64:
+ case ELF::R_SPARC_UA64:
return visitELF_SPARCV9_64(R, Value);
default:
HasError = true;
}
case Triple::amdgcn:
switch (RelocType) {
- case llvm::ELF::R_AMDGPU_ABS32:
+ case ELF::R_AMDGPU_ABS32:
return visitELF_AMDGPU_ABS32(R, Value);
- case llvm::ELF::R_AMDGPU_ABS64:
+ case ELF::R_AMDGPU_ABS64:
return visitELF_AMDGPU_ABS64(R, Value);
default:
HasError = true;
switch (ObjToVisit.getArch()) {
case Triple::x86:
switch (RelocType) {
- case llvm::ELF::R_386_NONE:
+ case ELF::R_386_NONE:
return visitELF_386_NONE(R);
- case llvm::ELF::R_386_32:
+ case ELF::R_386_32:
return visitELF_386_32(R, Value);
- case llvm::ELF::R_386_PC32:
+ case ELF::R_386_PC32:
return visitELF_386_PC32(R, Value);
default:
HasError = true;
}
case Triple::ppc:
switch (RelocType) {
- case llvm::ELF::R_PPC_ADDR32:
+ case ELF::R_PPC_ADDR32:
return visitELF_PPC_ADDR32(R, Value);
default:
HasError = true;
default:
HasError = true;
return RelocToApply();
- case llvm::ELF::R_ARM_ABS32:
+ case ELF::R_ARM_ABS32:
return visitELF_ARM_ABS32(R, Value);
}
case Triple::lanai:
switch (RelocType) {
- case llvm::ELF::R_LANAI_32:
+ case ELF::R_LANAI_32:
return visitELF_Lanai_32(R, Value);
default:
HasError = true;
case Triple::mipsel:
case Triple::mips:
switch (RelocType) {
- case llvm::ELF::R_MIPS_32:
+ case ELF::R_MIPS_32:
return visitELF_MIPS_32(R, Value);
default:
HasError = true;
}
case Triple::sparc:
switch (RelocType) {
- case llvm::ELF::R_SPARC_32:
- case llvm::ELF::R_SPARC_UA32:
+ case ELF::R_SPARC_32:
+ case ELF::R_SPARC_UA32:
return visitELF_SPARC_32(R, Value);
default:
HasError = true;
}
case Triple::hexagon:
switch (RelocType) {
- case llvm::ELF::R_HEX_32:
+ case ELF::R_HEX_32:
return visitELF_HEX_32(R, Value);
default:
HasError = true;
}
};
-}
-}
-#endif
+} // end namespace object
+} // end namespace llvm
+
+#endif // LLVM_OBJECT_RELOCVISITOR_H
#ifndef LLVM_OBJECT_WASM_H
#define LLVM_OBJECT_WASM_H
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/Object/Binary.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Support/Error.h"
class WasmSection {
public:
- WasmSection() : Type(0), Offset(0) {}
+ WasmSection() = default;
- uint32_t Type; // Section type (See below)
- uint32_t Offset; // Offset with in the file
+ uint32_t Type = 0; // Section type (See below)
+ uint32_t Offset = 0; // Offset with in the file
StringRef Name; // Section name (User-defined sections only)
ArrayRef<uint8_t> Content; // Section content
std::vector<wasm::WasmRelocation> Relocations; // Relocations for this section
const std::vector<wasm::WasmLimits>& memories() const { return Memories; }
const std::vector<wasm::WasmGlobal>& globals() const { return Globals; }
const std::vector<wasm::WasmExport>& exports() const { return Exports; }
+
const std::vector<wasm::WasmElemSegment>& elements() const {
return ElemSegments;
}
+
const std::vector<wasm::WasmDataSegment>& dataSegments() const {
return DataSegments;
}
+
const std::vector<wasm::WasmFunction>& functions() const { return Functions; }
const ArrayRef<uint8_t>& code() const { return CodeSection; }
uint32_t startFunction() const { return StartFunction; }
std::vector<WasmSymbol> Symbols;
std::vector<wasm::WasmFunction> Functions;
ArrayRef<uint8_t> CodeSection;
- uint32_t StartFunction;
+ uint32_t StartFunction = -1;
};
} // end namespace object
-//===- MachOObjectFile.cpp - Mach-O object file binding ---------*- C++ -*-===//
+//===- MachOObjectFile.cpp - Mach-O object file binding -------------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/Object/MachO.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/None.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/ADT/Triple.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Object/Error.h"
+#include "llvm/Object/MachO.h"
+#include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/SymbolicFile.h"
#include "llvm/Support/DataExtractor.h"
#include "llvm/Support/Debug.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/MachO.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
-#include <cctype>
+#include "llvm/Support/SwapByteOrder.h"
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
#include <cstring>
#include <limits>
#include <list>
+#include <memory>
+#include <string>
+#include <system_error>
using namespace llvm;
using namespace object;
namespace {
+
struct section_base {
char sectname[16];
char segname[16];
};
-}
+
+} // end anonymous namespace
static Error
malformedError(Twine Msg) {
bool Is64bits, Error &Err,
uint32_t UniversalCputype,
uint32_t UniversalIndex)
- : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object),
- SymtabLoadCmd(nullptr), DysymtabLoadCmd(nullptr),
- DataInCodeLoadCmd(nullptr), LinkOptHintsLoadCmd(nullptr),
- DyldInfoLoadCmd(nullptr), UuidLoadCmd(nullptr),
- HasPageZeroSegment(false) {
+ : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object) {
ErrorAsOutParameter ErrAsOutParam(&Err);
uint64_t SizeOfHeaders;
uint32_t cputype;
unsigned CPUType = getCPUType(*this);
if (!is64Bit()) {
switch (CPUType) {
- case llvm::MachO::CPU_TYPE_I386:
+ case MachO::CPU_TYPE_I386:
return "Mach-O 32-bit i386";
- case llvm::MachO::CPU_TYPE_ARM:
+ case MachO::CPU_TYPE_ARM:
return "Mach-O arm";
- case llvm::MachO::CPU_TYPE_POWERPC:
+ case MachO::CPU_TYPE_POWERPC:
return "Mach-O 32-bit ppc";
default:
return "Mach-O 32-bit unknown";
}
switch (CPUType) {
- case llvm::MachO::CPU_TYPE_X86_64:
+ case MachO::CPU_TYPE_X86_64:
return "Mach-O 64-bit x86-64";
- case llvm::MachO::CPU_TYPE_ARM64:
+ case MachO::CPU_TYPE_ARM64:
return "Mach-O arm64";
- case llvm::MachO::CPU_TYPE_POWERPC64:
+ case MachO::CPU_TYPE_POWERPC64:
return "Mach-O 64-bit ppc64";
default:
return "Mach-O 64-bit unknown";
Triple::ArchType MachOObjectFile::getArch(uint32_t CPUType) {
switch (CPUType) {
- case llvm::MachO::CPU_TYPE_I386:
+ case MachO::CPU_TYPE_I386:
return Triple::x86;
- case llvm::MachO::CPU_TYPE_X86_64:
+ case MachO::CPU_TYPE_X86_64:
return Triple::x86_64;
- case llvm::MachO::CPU_TYPE_ARM:
+ case MachO::CPU_TYPE_ARM:
return Triple::arm;
- case llvm::MachO::CPU_TYPE_ARM64:
+ case MachO::CPU_TYPE_ARM64:
return Triple::aarch64;
- case llvm::MachO::CPU_TYPE_POWERPC:
+ case MachO::CPU_TYPE_POWERPC:
return Triple::ppc;
- case llvm::MachO::CPU_TYPE_POWERPC64:
+ case MachO::CPU_TYPE_POWERPC64:
return Triple::ppc64;
default:
return Triple::UnknownArch;
return dice_iterator(DiceRef(DRI, this));
}
-ExportEntry::ExportEntry(ArrayRef<uint8_t> T)
- : Trie(T), Malformed(false), Done(false) {}
+ExportEntry::ExportEntry(ArrayRef<uint8_t> T) : Trie(T) {}
void ExportEntry::moveToFirst() {
pushNode(0);
}
ExportEntry::NodeState::NodeState(const uint8_t *Ptr)
- : Start(Ptr), Current(Ptr), Flags(0), Address(0), Other(0),
- ImportName(nullptr), ChildCount(0), NextChildIndex(0),
- ParentStringLength(0), IsExportNode(false) {}
+ : Start(Ptr), Current(Ptr) {}
void ExportEntry::pushNode(uint64_t offset) {
const uint8_t *Ptr = Trie.begin() + offset;
iterator_range<export_iterator>
MachOObjectFile::exports(ArrayRef<uint8_t> Trie) {
ExportEntry Start(Trie);
- if (Trie.size() == 0)
+ if (Trie.empty())
Start.moveToEnd();
else
Start.moveToFirst();
MachORebaseEntry::MachORebaseEntry(Error *E, const MachOObjectFile *O,
ArrayRef<uint8_t> Bytes, bool is64Bit)
- : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0),
- SegmentIndex(-1), RemainingLoopCount(0), AdvanceAmount(0), RebaseType(0),
- PointerSize(is64Bit ? 8 : 4), Done(false) {}
+ : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
+ PointerSize(is64Bit ? 8 : 4) {}
void MachORebaseEntry::moveToFirst() {
Ptr = Opcodes.begin();
More = false;
Done = true;
moveToEnd();
- DEBUG_WITH_TYPE("mach-o-rebase", llvm::dbgs() << "REBASE_OPCODE_DONE\n");
+ DEBUG_WITH_TYPE("mach-o-rebase", dbgs() << "REBASE_OPCODE_DONE\n");
break;
case MachO::REBASE_OPCODE_SET_TYPE_IMM:
RebaseType = ImmValue;
}
DEBUG_WITH_TYPE(
"mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
- << "RebaseType=" << (int) RebaseType << "\n");
+ dbgs() << "REBASE_OPCODE_SET_TYPE_IMM: "
+ << "RebaseType=" << (int) RebaseType << "\n");
break;
case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
SegmentIndex = ImmValue;
}
DEBUG_WITH_TYPE(
"mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
- << "SegmentIndex=" << SegmentIndex << ", "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << "\n");
+ dbgs() << "REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
+ << "SegmentIndex=" << SegmentIndex << ", "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << "\n");
break;
case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
SegmentOffset += readULEB128(&error);
return;
}
DEBUG_WITH_TYPE("mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
- << format("SegmentOffset=0x%06X",
- SegmentOffset) << "\n");
+ dbgs() << "REBASE_OPCODE_ADD_ADDR_ULEB: "
+ << format("SegmentOffset=0x%06X",
+ SegmentOffset) << "\n");
break;
case MachO::REBASE_OPCODE_ADD_ADDR_IMM_SCALED:
error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
return;
}
DEBUG_WITH_TYPE("mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
- << format("SegmentOffset=0x%06X",
- SegmentOffset) << "\n");
+ dbgs() << "REBASE_OPCODE_ADD_ADDR_IMM_SCALED: "
+ << format("SegmentOffset=0x%06X",
+ SegmentOffset) << "\n");
break;
case MachO::REBASE_OPCODE_DO_REBASE_IMM_TIMES:
error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
}
DEBUG_WITH_TYPE(
"mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << ", AdvanceAmount=" << AdvanceAmount
- << ", RemainingLoopCount=" << RemainingLoopCount
- << "\n");
+ dbgs() << "REBASE_OPCODE_DO_REBASE_IMM_TIMES: "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << ", AdvanceAmount=" << AdvanceAmount
+ << ", RemainingLoopCount=" << RemainingLoopCount
+ << "\n");
return;
case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
}
DEBUG_WITH_TYPE(
"mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << ", AdvanceAmount=" << AdvanceAmount
- << ", RemainingLoopCount=" << RemainingLoopCount
- << "\n");
+ dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES: "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << ", AdvanceAmount=" << AdvanceAmount
+ << ", RemainingLoopCount=" << RemainingLoopCount
+ << "\n");
return;
case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
}
DEBUG_WITH_TYPE(
"mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << ", AdvanceAmount=" << AdvanceAmount
- << ", RemainingLoopCount=" << RemainingLoopCount
- << "\n");
+ dbgs() << "REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << ", AdvanceAmount=" << AdvanceAmount
+ << ", RemainingLoopCount=" << RemainingLoopCount
+ << "\n");
return;
case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
error = O->RebaseEntryCheckSegAndOffset(SegmentIndex, SegmentOffset,
}
DEBUG_WITH_TYPE(
"mach-o-rebase",
- llvm::dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << ", AdvanceAmount=" << AdvanceAmount
- << ", RemainingLoopCount=" << RemainingLoopCount
- << "\n");
+ dbgs() << "REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << ", AdvanceAmount=" << AdvanceAmount
+ << ", RemainingLoopCount=" << RemainingLoopCount
+ << "\n");
return;
default:
*E = malformedError("bad rebase info (bad opcode value 0x" +
MachOBindEntry::MachOBindEntry(Error *E, const MachOObjectFile *O,
ArrayRef<uint8_t> Bytes, bool is64Bit, Kind BK)
- : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()), SegmentOffset(0),
- SegmentIndex(-1), LibraryOrdinalSet(false), Ordinal(0), Flags(0),
- Addend(0), RemainingLoopCount(0), AdvanceAmount(0), BindType(0),
- PointerSize(is64Bit ? 8 : 4), TableKind(BK), Done(false) {}
+ : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
+ PointerSize(is64Bit ? 8 : 4), TableKind(BK) {}
void MachOBindEntry::moveToFirst() {
Ptr = Opcodes.begin();
}
More = false;
moveToEnd();
- DEBUG_WITH_TYPE("mach-o-bind", llvm::dbgs() << "BIND_OPCODE_DONE\n");
+ DEBUG_WITH_TYPE("mach-o-bind", dbgs() << "BIND_OPCODE_DONE\n");
break;
case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:
if (TableKind == Kind::Weak) {
}
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
- << "Ordinal=" << Ordinal << "\n");
+ dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: "
+ << "Ordinal=" << Ordinal << "\n");
break;
case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
if (TableKind == Kind::Weak) {
}
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
- << "Ordinal=" << Ordinal << "\n");
+ dbgs() << "BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: "
+ << "Ordinal=" << Ordinal << "\n");
break;
case MachO::BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:
if (TableKind == Kind::Weak) {
Ordinal = 0;
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
- << "Ordinal=" << Ordinal << "\n");
+ dbgs() << "BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: "
+ << "Ordinal=" << Ordinal << "\n");
break;
case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
Flags = ImmValue;
++Ptr;
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
- << "SymbolName=" << SymbolName << "\n");
+ dbgs() << "BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: "
+ << "SymbolName=" << SymbolName << "\n");
if (TableKind == Kind::Weak) {
if (ImmValue & MachO::BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
return;
}
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
- << "BindType=" << (int)BindType << "\n");
+ dbgs() << "BIND_OPCODE_SET_TYPE_IMM: "
+ << "BindType=" << (int)BindType << "\n");
break;
case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
Addend = readSLEB128(&error);
}
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
- << "Addend=" << Addend << "\n");
+ dbgs() << "BIND_OPCODE_SET_ADDEND_SLEB: "
+ << "Addend=" << Addend << "\n");
break;
case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
SegmentIndex = ImmValue;
}
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
- << "SegmentIndex=" << SegmentIndex << ", "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << "\n");
+ dbgs() << "BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: "
+ << "SegmentIndex=" << SegmentIndex << ", "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << "\n");
break;
case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
SegmentOffset += readULEB128(&error);
return;
}
DEBUG_WITH_TYPE("mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
- << format("SegmentOffset=0x%06X",
- SegmentOffset) << "\n");
+ dbgs() << "BIND_OPCODE_ADD_ADDR_ULEB: "
+ << format("SegmentOffset=0x%06X",
+ SegmentOffset) << "\n");
break;
case MachO::BIND_OPCODE_DO_BIND:
AdvanceAmount = PointerSize;
return;
}
DEBUG_WITH_TYPE("mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_DO_BIND: "
- << format("SegmentOffset=0x%06X",
- SegmentOffset) << "\n");
+ dbgs() << "BIND_OPCODE_DO_BIND: "
+ << format("SegmentOffset=0x%06X",
+ SegmentOffset) << "\n");
return;
case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
if (TableKind == Kind::Lazy) {
RemainingLoopCount = 0;
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << ", AdvanceAmount=" << AdvanceAmount
- << ", RemainingLoopCount=" << RemainingLoopCount
- << "\n");
+ dbgs() << "BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << ", AdvanceAmount=" << AdvanceAmount
+ << ", RemainingLoopCount=" << RemainingLoopCount
+ << "\n");
return;
case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
if (TableKind == Kind::Lazy) {
return;
}
DEBUG_WITH_TYPE("mach-o-bind",
- llvm::dbgs()
+ dbgs()
<< "BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: "
- << format("SegmentOffset=0x%06X",
- SegmentOffset) << "\n");
+ << format("SegmentOffset=0x%06X", SegmentOffset) << "\n");
return;
case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
if (TableKind == Kind::Lazy) {
}
DEBUG_WITH_TYPE(
"mach-o-bind",
- llvm::dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
- << format("SegmentOffset=0x%06X", SegmentOffset)
- << ", AdvanceAmount=" << AdvanceAmount
- << ", RemainingLoopCount=" << RemainingLoopCount
- << "\n");
+ dbgs() << "BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: "
+ << format("SegmentOffset=0x%06X", SegmentOffset)
+ << ", AdvanceAmount=" << AdvanceAmount
+ << ", RemainingLoopCount=" << RemainingLoopCount
+ << "\n");
return;
default:
*E = malformedError("bad bind info (bad opcode value 0x" +
-//===- ModuleSummaryIndexObjectFile.cpp - Summary index file implementation ==//
+//==- ModuleSummaryIndexObjectFile.cpp - Summary index file implementation -==//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
-#include "llvm/Object/ModuleSummaryIndexObjectFile.h"
#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/Bitcode/BitcodeReader.h"
#include "llvm/IR/ModuleSummaryIndex.h"
-#include "llvm/MC/MCStreamer.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/Error.h"
+#include "llvm/Object/ModuleSummaryIndexObjectFile.h"
#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorOr.h"
+#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <memory>
+#include <system_error>
+
using namespace llvm;
using namespace object;
-static llvm::cl::opt<bool> IgnoreEmptyThinLTOIndexFile(
- "ignore-empty-index-file", llvm::cl::ZeroOrMore,
- llvm::cl::desc(
+static cl::opt<bool> IgnoreEmptyThinLTOIndexFile(
+ "ignore-empty-index-file", cl::ZeroOrMore,
+ cl::desc(
"Ignore an empty index file and perform non-ThinLTO compilation"),
- llvm::cl::init(false));
+ cl::init(false));
ModuleSummaryIndexObjectFile::ModuleSummaryIndexObjectFile(
MemoryBufferRef Object, std::unique_ptr<ModuleSummaryIndex> I)
: SymbolicFile(Binary::ID_ModuleSummaryIndex, Object), Index(std::move(I)) {
}
-ModuleSummaryIndexObjectFile::~ModuleSummaryIndexObjectFile() {}
+ModuleSummaryIndexObjectFile::~ModuleSummaryIndexObjectFile() = default;
std::unique_ptr<ModuleSummaryIndex> ModuleSummaryIndexObjectFile::takeIndex() {
return std::move(Index);
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
+#include "llvm/MC/SubtargetFeature.h"
#include "llvm/Object/Binary.h"
#include "llvm/Object/Error.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/Wasm.h"
#include <algorithm>
+#include <cassert>
#include <cstdint>
+#include <cstring>
#include <system_error>
using namespace llvm;
}
WasmObjectFile::WasmObjectFile(MemoryBufferRef Buffer, Error &Err)
- : ObjectFile(Binary::ID_Wasm, Buffer), StartFunction(-1) {
+ : ObjectFile(Binary::ID_Wasm, Buffer) {
ErrorAsOutParameter ErrAsOutParam(&Err);
Header.Magic = getData().substr(0, 4);
if (Header.Magic != StringRef("\0asm", 4)) {
while (Count--) {
/*uint32_t Index =*/readVaruint32(Ptr);
StringRef Name = readString(Ptr);
- if (Name.size())
+ if (!Name.empty())
Symbols.emplace_back(Name,
WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME);
}
projects / llvm / commitdiff