#include "llvm/ADT/SmallString.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCObjectWriter.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/DataTypes.h"
+#include "llvm/Support/MachO.h"
#include <vector>
namespace llvm {
/// @{
llvm::DenseMap<const MCSectionData*,
- std::vector<object::macho::RelocationEntry> > Relocations;
+ std::vector<MachO::any_relocation_info> > Relocations;
llvm::DenseMap<const MCSectionData*, unsigned> IndirectSymBase;
/// @}
bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
bool isARM() const {
- uint32_t CPUType = TargetObjectWriter->getCPUType() &
- ~object::mach::CTFM_ArchMask;
- return CPUType == object::mach::CTM_ARM;
+ uint32_t CPUType = TargetObjectWriter->getCPUType() & ~MachO::CPU_ARCH_MASK;
+ return CPUType == MachO::CPU_TYPE_ARM;
}
/// @}
// these through in many cases.
void addRelocation(const MCSectionData *SD,
- object::macho::RelocationEntry &MRE) {
+ MachO::any_relocation_info &MRE) {
Relocations[SD].push_back(MRE);
}
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Triple.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/MachO.h"
namespace llvm {
namespace object {
public:
struct LoadCommandInfo {
const char *Ptr; // Where in memory the load command is.
- macho::LoadCommand C; // The command itself.
+ MachO::load_command C; // The command itself.
};
MachOObjectFile(MemoryBuffer *Object, bool IsLittleEndian, bool Is64Bits,
ArrayRef<char> getSectionRawFinalSegmentName(DataRefImpl Sec) const;
// MachO specific Info about relocations.
- bool isRelocationScattered(const macho::RelocationEntry &RE) const;
- unsigned getPlainRelocationSymbolNum(const macho::RelocationEntry &RE) const;
- bool getPlainRelocationExternal(const macho::RelocationEntry &RE) const;
- bool getScatteredRelocationScattered(const macho::RelocationEntry &RE) const;
- uint32_t getScatteredRelocationValue(const macho::RelocationEntry &RE) const;
- unsigned getAnyRelocationAddress(const macho::RelocationEntry &RE) const;
- unsigned getAnyRelocationPCRel(const macho::RelocationEntry &RE) const;
- unsigned getAnyRelocationLength(const macho::RelocationEntry &RE) const;
- unsigned getAnyRelocationType(const macho::RelocationEntry &RE) const;
- SectionRef getRelocationSection(const macho::RelocationEntry &RE) const;
+ bool isRelocationScattered(const MachO::any_relocation_info &RE) const;
+ unsigned getPlainRelocationSymbolNum(
+ const MachO::any_relocation_info &RE) const;
+ bool getPlainRelocationExternal(const MachO::any_relocation_info &RE) const;
+ bool getScatteredRelocationScattered(
+ const MachO::any_relocation_info &RE) const;
+ uint32_t getScatteredRelocationValue(
+ const MachO::any_relocation_info &RE) const;
+ unsigned getAnyRelocationAddress(const MachO::any_relocation_info &RE) const;
+ unsigned getAnyRelocationPCRel(const MachO::any_relocation_info &RE) const;
+ unsigned getAnyRelocationLength(const MachO::any_relocation_info &RE) const;
+ unsigned getAnyRelocationType(const MachO::any_relocation_info &RE) const;
+ SectionRef getRelocationSection(const MachO::any_relocation_info &RE) const;
// Walk load commands.
LoadCommandInfo getFirstLoadCommandInfo() const;
LoadCommandInfo getNextLoadCommandInfo(const LoadCommandInfo &L) const;
// MachO specific structures.
- macho::Section getSection(DataRefImpl DRI) const;
- macho::Section64 getSection64(DataRefImpl DRI) const;
- macho::Section getSection(const LoadCommandInfo &L, unsigned Index) const;
- macho::Section64 getSection64(const LoadCommandInfo &L, unsigned Index) const;
- macho::SymbolTableEntry getSymbolTableEntry(DataRefImpl DRI) const;
- macho::Symbol64TableEntry getSymbol64TableEntry(DataRefImpl DRI) const;
-
- macho::LinkeditDataLoadCommand
+ MachO::section getSection(DataRefImpl DRI) const;
+ MachO::section_64 getSection64(DataRefImpl DRI) const;
+ MachO::section getSection(const LoadCommandInfo &L, unsigned Index) const;
+ MachO::section_64 getSection64(const LoadCommandInfo &L,unsigned Index) const;
+ MachO::nlist getSymbolTableEntry(DataRefImpl DRI) const;
+ MachO::nlist_64 getSymbol64TableEntry(DataRefImpl DRI) const;
+
+ MachO::linkedit_data_command
getLinkeditDataLoadCommand(const LoadCommandInfo &L) const;
- macho::SegmentLoadCommand
+ MachO::segment_command
getSegmentLoadCommand(const LoadCommandInfo &L) const;
- macho::Segment64LoadCommand
+ MachO::segment_command_64
getSegment64LoadCommand(const LoadCommandInfo &L) const;
- macho::LinkerOptionsLoadCommand
+ MachO::linker_options_command
getLinkerOptionsLoadCommand(const LoadCommandInfo &L) const;
- macho::RelocationEntry getRelocation(DataRefImpl Rel) const;
- macho::DataInCodeTableEntry getDice(DataRefImpl Rel) const;
- macho::Header getHeader() const;
- macho::Header64Ext getHeader64Ext() const;
- macho::IndirectSymbolTableEntry
- getIndirectSymbolTableEntry(const macho::DysymtabLoadCommand &DLC,
+ MachO::any_relocation_info getRelocation(DataRefImpl Rel) const;
+ MachO::data_in_code_entry getDice(DataRefImpl Rel) const;
+ MachO::mach_header getHeader() const;
+ MachO::mach_header_64 getHeader64() const;
+ uint32_t
+ getIndirectSymbolTableEntry(const MachO::dysymtab_command &DLC,
unsigned Index) const;
- macho::DataInCodeTableEntry getDataInCodeTableEntry(uint32_t DataOffset,
- unsigned Index) const;
- macho::SymtabLoadCommand getSymtabLoadCommand() const;
- macho::DysymtabLoadCommand getDysymtabLoadCommand() const;
- macho::LinkeditDataLoadCommand getDataInCodeLoadCommand() const;
+ MachO::data_in_code_entry getDataInCodeTableEntry(uint32_t DataOffset,
+ unsigned Index) const;
+ MachO::symtab_command getSymtabLoadCommand() const;
+ MachO::dysymtab_command getDysymtabLoadCommand() const;
+ MachO::linkedit_data_command getDataInCodeLoadCommand() const;
StringRef getStringTableData() const;
bool is64Bit() const;
inline error_code DiceRef::getNext(DiceRef &Result) const {
DataRefImpl Rel = DicePimpl;
- const macho::DataInCodeTableEntry *P =
- reinterpret_cast<const macho::DataInCodeTableEntry *>(Rel.p);
+ const MachO::data_in_code_entry *P =
+ reinterpret_cast<const MachO::data_in_code_entry *>(Rel.p);
Rel.p = reinterpret_cast<uintptr_t>(P + 1);
Result = DiceRef(Rel, OwningObject);
return object_error::success;
inline error_code DiceRef::getOffset(uint32_t &Result) const {
const MachOObjectFile *MachOOF =
static_cast<const MachOObjectFile *>(OwningObject);
- macho::DataInCodeTableEntry Dice = MachOOF->getDice(DicePimpl);
- Result = Dice.Offset;
+ MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
+ Result = Dice.offset;
return object_error::success;
}
inline error_code DiceRef::getLength(uint16_t &Result) const {
const MachOObjectFile *MachOOF =
static_cast<const MachOObjectFile *>(OwningObject);
- macho::DataInCodeTableEntry Dice = MachOOF->getDice(DicePimpl);
- Result = Dice.Length;
+ MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
+ Result = Dice.length;
return object_error::success;
}
inline error_code DiceRef::getKind(uint16_t &Result) const {
const MachOObjectFile *MachOOF =
static_cast<const MachOObjectFile *>(OwningObject);
- macho::DataInCodeTableEntry Dice = MachOOF->getDice(DicePimpl);
- Result = Dice.Kind;
+ MachO::data_in_code_entry Dice = MachOOF->getDice(DicePimpl);
+ Result = Dice.kind;
return object_error::success;
}
+++ /dev/null
-//===- MachOFormat.h - Mach-O Format Structures And Constants ---*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file declares various structures and constants which are platform
-// independent and can be shared by any client which wishes to interact with
-// Mach object files.
-//
-// The definitions here are purposely chosen to match the LLVM style as opposed
-// to following the platform specific definition of the format.
-//
-// On a Mach system, see the <mach-o/...> includes for more information, in
-// particular <mach-o/loader.h>.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_OBJECT_MACHOFORMAT_H
-#define LLVM_OBJECT_MACHOFORMAT_H
-
-#include "llvm/Support/DataTypes.h"
-
-namespace llvm {
-namespace object {
-
-/// General Mach platform information.
-namespace mach {
- /// @name CPU Type and Subtype Information
- /// {
-
- /// \brief Capability bits used in CPU type encoding.
- enum CPUTypeFlagsMask {
- CTFM_ArchMask = 0xFF000000,
- CTFM_ArchABI64 = 0x01000000
- };
-
- /// \brief Machine type IDs used in CPU type encoding.
- enum CPUTypeMachine {
- CTM_i386 = 7,
- CTM_x86_64 = CTM_i386 | CTFM_ArchABI64,
- CTM_ARM = 12,
- CTM_SPARC = 14,
- CTM_PowerPC = 18,
- CTM_PowerPC64 = CTM_PowerPC | CTFM_ArchABI64
- };
-
- /// \brief Capability bits used in CPU subtype encoding.
- enum CPUSubtypeFlagsMask {
- CSFM_SubtypeMask = 0xFF000000,
- CSFM_SubtypeLib64 = 0x80000000
- };
-
- /// \brief ARM Machine Subtypes.
- enum CPUSubtypeARM {
- CSARM_ALL = 0,
- CSARM_V4T = 5,
- CSARM_V6 = 6,
- CSARM_V5TEJ = 7,
- CSARM_XSCALE = 8,
- CSARM_V7 = 9,
- CSARM_V7F = 10,
- CSARM_V7S = 11,
- CSARM_V7K = 12,
- CSARM_V6M = 14,
- CSARM_V7M = 15,
- CSARM_V7EM = 16
- };
-
- /// \brief PowerPC Machine Subtypes.
- enum CPUSubtypePowerPC {
- CSPPC_ALL = 0
- };
-
- /// \brief SPARC Machine Subtypes.
- enum CPUSubtypeSPARC {
- CSSPARC_ALL = 0
- };
-
- /// \brief x86 Machine Subtypes.
- enum CPUSubtypeX86 {
- CSX86_ALL = 3
- };
-
- /// @}
-
-} // end namespace mach
-
-/// Format information for Mach object files.
-namespace macho {
- /// \brief Constants for structure sizes.
- enum StructureSizes {
- Header32Size = 28,
- Header64Size = 32,
- FatHeaderSize = 8,
- FatArchHeaderSize = 20,
- SegmentLoadCommand32Size = 56,
- SegmentLoadCommand64Size = 72,
- Section32Size = 68,
- Section64Size = 80,
- SymtabLoadCommandSize = 24,
- DysymtabLoadCommandSize = 80,
- Nlist32Size = 12,
- Nlist64Size = 16,
- RelocationInfoSize = 8,
- LinkeditLoadCommandSize = 16
- };
-
- /// \brief Constants for header magic field.
- enum HeaderMagic {
- HM_Object32 = 0xFEEDFACE, ///< 32-bit mach object file
- HM_Object64 = 0xFEEDFACF, ///< 64-bit mach object file
- HM_Universal = 0xCAFEBABE ///< Universal object file
- };
-
- /// \brief Header common to all Mach object files.
- struct Header {
- uint32_t Magic;
- uint32_t CPUType;
- uint32_t CPUSubtype;
- uint32_t FileType;
- uint32_t NumLoadCommands;
- uint32_t SizeOfLoadCommands;
- uint32_t Flags;
- };
-
- /// \brief Extended header for 64-bit object files.
- struct Header64Ext {
- uint32_t Reserved;
- };
-
- /// \brief Header for universal object files.
- struct FatHeader {
- uint32_t Magic;
- uint32_t NumFatArch;
- };
-
- /// \brief Header for a single-architecture object file in a
- /// universal binary.
- struct FatArchHeader {
- uint32_t CPUType;
- uint32_t CPUSubtype;
- uint32_t Offset;
- uint32_t Size;
- uint32_t Align;
- };
-
- // See <mach-o/loader.h>.
- enum HeaderFileType {
- HFT_Object = 0x1
- };
-
- enum HeaderFlags {
- HF_SubsectionsViaSymbols = 0x2000
- };
-
- enum LoadCommandType {
- LCT_Segment = 0x1,
- LCT_Symtab = 0x2,
- LCT_Dysymtab = 0xb,
- LCT_Segment64 = 0x19,
- LCT_UUID = 0x1b,
- LCT_CodeSignature = 0x1d,
- LCT_SegmentSplitInfo = 0x1e,
- LCT_FunctionStarts = 0x26,
- LCT_DataInCode = 0x29,
- LCT_LinkerOptions = 0x2D
- };
-
- /// \brief Load command structure.
- struct LoadCommand {
- uint32_t Type;
- uint32_t Size;
- };
-
- /// @name Load Command Structures
- /// @{
-
- struct SegmentLoadCommand {
- uint32_t Type;
- uint32_t Size;
- char Name[16];
- uint32_t VMAddress;
- uint32_t VMSize;
- uint32_t FileOffset;
- uint32_t FileSize;
- uint32_t MaxVMProtection;
- uint32_t InitialVMProtection;
- uint32_t NumSections;
- uint32_t Flags;
- };
-
- struct Segment64LoadCommand {
- uint32_t Type;
- uint32_t Size;
- char Name[16];
- uint64_t VMAddress;
- uint64_t VMSize;
- uint64_t FileOffset;
- uint64_t FileSize;
- uint32_t MaxVMProtection;
- uint32_t InitialVMProtection;
- uint32_t NumSections;
- uint32_t Flags;
- };
-
- struct SymtabLoadCommand {
- uint32_t Type;
- uint32_t Size;
- uint32_t SymbolTableOffset;
- uint32_t NumSymbolTableEntries;
- uint32_t StringTableOffset;
- uint32_t StringTableSize;
- };
-
- struct DysymtabLoadCommand {
- uint32_t Type;
- uint32_t Size;
-
- uint32_t LocalSymbolsIndex;
- uint32_t NumLocalSymbols;
-
- uint32_t ExternalSymbolsIndex;
- uint32_t NumExternalSymbols;
-
- uint32_t UndefinedSymbolsIndex;
- uint32_t NumUndefinedSymbols;
-
- uint32_t TOCOffset;
- uint32_t NumTOCEntries;
-
- uint32_t ModuleTableOffset;
- uint32_t NumModuleTableEntries;
-
- uint32_t ReferenceSymbolTableOffset;
- uint32_t NumReferencedSymbolTableEntries;
-
- uint32_t IndirectSymbolTableOffset;
- uint32_t NumIndirectSymbolTableEntries;
-
- uint32_t ExternalRelocationTableOffset;
- uint32_t NumExternalRelocationTableEntries;
-
- uint32_t LocalRelocationTableOffset;
- uint32_t NumLocalRelocationTableEntries;
- };
-
- struct LinkeditDataLoadCommand {
- uint32_t Type;
- uint32_t Size;
- uint32_t DataOffset;
- uint32_t DataSize;
- };
-
- struct LinkerOptionsLoadCommand {
- uint32_t Type;
- uint32_t Size;
- uint32_t Count;
- // Load command is followed by Count number of zero-terminated UTF8 strings,
- // and then zero-filled to be 4-byte aligned.
- };
-
- /// @}
- /// @name Section Data
- /// @{
-
- enum SectionFlags {
- SF_PureInstructions = 0x80000000
- };
-
- struct Section {
- char Name[16];
- char SegmentName[16];
- uint32_t Address;
- uint32_t Size;
- uint32_t Offset;
- uint32_t Align;
- uint32_t RelocationTableOffset;
- uint32_t NumRelocationTableEntries;
- uint32_t Flags;
- uint32_t Reserved1;
- uint32_t Reserved2;
- };
- struct Section64 {
- char Name[16];
- char SegmentName[16];
- uint64_t Address;
- uint64_t Size;
- uint32_t Offset;
- uint32_t Align;
- uint32_t RelocationTableOffset;
- uint32_t NumRelocationTableEntries;
- uint32_t Flags;
- uint32_t Reserved1;
- uint32_t Reserved2;
- uint32_t Reserved3;
- };
-
- /// @}
- /// @name Symbol Table Entries
- /// @{
-
- struct SymbolTableEntry {
- uint32_t StringIndex;
- uint8_t Type;
- uint8_t SectionIndex;
- uint16_t Flags;
- uint32_t Value;
- };
- // Despite containing a uint64_t, this structure is only 4-byte aligned within
- // a MachO file.
-#pragma pack(push)
-#pragma pack(4)
- struct Symbol64TableEntry {
- uint32_t StringIndex;
- uint8_t Type;
- uint8_t SectionIndex;
- uint16_t Flags;
- uint64_t Value;
- };
-#pragma pack(pop)
-
- /// @}
- /// @name Data-in-code Table Entry
- /// @{
-
- // See <mach-o/loader.h>.
- enum DataRegionType { Data = 1, JumpTable8, JumpTable16, JumpTable32 };
- struct DataInCodeTableEntry {
- uint32_t Offset; /* from mach_header to start of data region */
- uint16_t Length; /* number of bytes in data region */
- uint16_t Kind; /* a DataRegionType value */
- };
-
- /// @}
- /// @name Indirect Symbol Table
- /// @{
-
- struct IndirectSymbolTableEntry {
- uint32_t Index;
- };
-
- /// @}
- /// @name Relocation Data
- /// @{
-
- struct RelocationEntry {
- uint32_t Word0;
- uint32_t Word1;
- };
-
- /// @}
-
- // See <mach-o/nlist.h>.
- enum SymbolTypeType {
- STT_Undefined = 0x00,
- STT_Absolute = 0x02,
- STT_Section = 0x0e
- };
-
- enum SymbolTypeFlags {
- // If any of these bits are set, then the entry is a stab entry number (see
- // <mach-o/stab.h>. Otherwise the other masks apply.
- STF_StabsEntryMask = 0xe0,
-
- STF_TypeMask = 0x0e,
- STF_External = 0x01,
- STF_PrivateExtern = 0x10
- };
-
- /// IndirectSymbolFlags - Flags for encoding special values in the indirect
- /// symbol entry.
- enum IndirectSymbolFlags {
- ISF_Local = 0x80000000,
- ISF_Absolute = 0x40000000
- };
-
- /// RelocationFlags - Special flags for addresses.
- enum RelocationFlags {
- RF_Scattered = 0x80000000
- };
-
- /// Common relocation info types.
- enum RelocationInfoType {
- RIT_Vanilla = 0,
- RIT_Pair = 1,
- RIT_Difference = 2
- };
-
- /// Generic relocation info types, which are shared by some (but not all)
- /// platforms.
- enum RelocationInfoType_Generic {
- RIT_Generic_PreboundLazyPointer = 3,
- RIT_Generic_LocalDifference = 4,
- RIT_Generic_TLV = 5
- };
-
- /// X86_64 uses its own relocation types.
- enum RelocationInfoTypeX86_64 {
- // Note that x86_64 doesn't even share the common relocation types.
- RIT_X86_64_Unsigned = 0,
- RIT_X86_64_Signed = 1,
- RIT_X86_64_Branch = 2,
- RIT_X86_64_GOTLoad = 3,
- RIT_X86_64_GOT = 4,
- RIT_X86_64_Subtractor = 5,
- RIT_X86_64_Signed1 = 6,
- RIT_X86_64_Signed2 = 7,
- RIT_X86_64_Signed4 = 8,
- RIT_X86_64_TLV = 9
- };
-
- /// ARM uses its own relocation types.
- enum RelocationInfoTypeARM {
- RIT_ARM_LocalDifference = 3,
- RIT_ARM_PreboundLazyPointer = 4,
- RIT_ARM_Branch24Bit = 5,
- RIT_ARM_ThumbBranch22Bit = 6,
- RIT_ARM_ThumbBranch32Bit = 7,
- RIT_ARM_Half = 8,
- RIT_ARM_HalfDifference = 9
-
- };
-
- /// PPC relocation types from <mach-o/ppc/reloc.h>
- enum RelocationInfoTypePPC {
- RIT_PPC_BR14 = RIT_Pair +1,
- RIT_PPC_BR24,
- RIT_PPC_HI16,
- RIT_PPC_LO16,
- RIT_PPC_HA16,
- RIT_PPC_LO14,
- RIT_PPC_SECTDIFF,
- RIT_PPC_PB_LA_PTR,
- RIT_PPC_HI16_SECTDIFF,
- RIT_PPC_LO16_SECTDIFF,
- RIT_PPC_HA16_SECTDIFF,
- RIT_PPC_JBSR,
- RIT_PPC_LO14_SECTDIFF,
- RIT_PPC_LOCAL_SECTDIFF,
- RIT_PPC_TLV
- };
-
-} // end namespace macho
-
-} // end namespace object
-} // end namespace llvm
-
-#endif
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Object/Binary.h"
-#include "llvm/Object/MachOFormat.h"
+#include "llvm/Support/MachO.h"
namespace llvm {
namespace object {
/// \brief Index of object in the universal binary.
uint32_t Index;
/// \brief Descriptor of the object.
- macho::FatArchHeader Header;
+ MachO::fat_arch Header;
public:
ObjectForArch(const MachOUniversalBinary *Parent, uint32_t Index);
}
ObjectForArch getNext() const { return ObjectForArch(Parent, Index + 1); }
- uint32_t getCPUType() const { return Header.CPUType; }
+ uint32_t getCPUType() const { return Header.cputype; }
error_code getAsObjectFile(OwningPtr<ObjectFile> &Result) const;
};
switch (Type) {
default:
llvm_unreachable("Invalid relocation type!");
- case macho::RIT_Vanilla: {
+ case MachO::GENERIC_RELOC_VANILLA: {
uint8_t *p = LocalAddress;
uint64_t ValueToWrite = Value + Addend;
for (unsigned i = 0; i < Size; ++i) {
}
return false;
}
- case macho::RIT_Difference:
- case macho::RIT_Generic_LocalDifference:
- case macho::RIT_Generic_PreboundLazyPointer:
+ case MachO::GENERIC_RELOC_SECTDIFF:
+ case MachO::GENERIC_RELOC_LOCAL_SECTDIFF:
+ case MachO::GENERIC_RELOC_PB_LA_PTR:
return Error("Relocation type not implemented yet!");
}
}
switch(Type) {
default:
llvm_unreachable("Invalid relocation type!");
- case macho::RIT_X86_64_Signed1:
- case macho::RIT_X86_64_Signed2:
- case macho::RIT_X86_64_Signed4:
- case macho::RIT_X86_64_Signed:
- case macho::RIT_X86_64_Unsigned:
- case macho::RIT_X86_64_Branch: {
+ case MachO::X86_64_RELOC_SIGNED_1:
+ case MachO::X86_64_RELOC_SIGNED_2:
+ case MachO::X86_64_RELOC_SIGNED_4:
+ case MachO::X86_64_RELOC_SIGNED:
+ case MachO::X86_64_RELOC_UNSIGNED:
+ case MachO::X86_64_RELOC_BRANCH: {
Value += Addend;
// Mask in the target value a byte at a time (we don't have an alignment
// guarantee for the target address, so this is safest).
}
return false;
}
- case macho::RIT_X86_64_GOTLoad:
- case macho::RIT_X86_64_GOT:
- case macho::RIT_X86_64_Subtractor:
- case macho::RIT_X86_64_TLV:
+ case MachO::X86_64_RELOC_GOT_LOAD:
+ case MachO::X86_64_RELOC_GOT:
+ case MachO::X86_64_RELOC_SUBTRACTOR:
+ case MachO::X86_64_RELOC_TLV:
return Error("Relocation type not implemented yet!");
}
}
switch(Type) {
default:
llvm_unreachable("Invalid relocation type!");
- case macho::RIT_Vanilla: {
+ case MachO::ARM_RELOC_VANILLA: {
// Mask in the target value a byte at a time (we don't have an alignment
// guarantee for the target address, so this is safest).
uint8_t *p = (uint8_t*)LocalAddress;
}
break;
}
- case macho::RIT_ARM_Branch24Bit: {
+ case MachO::ARM_RELOC_BR24: {
// Mask the value into the target address. We know instructions are
// 32-bit aligned, so we can do it all at once.
uint32_t *p = (uint32_t*)LocalAddress;
*p = (*p & ~0xffffff) | Value;
break;
}
- case macho::RIT_ARM_ThumbBranch22Bit:
- case macho::RIT_ARM_ThumbBranch32Bit:
- case macho::RIT_ARM_Half:
- case macho::RIT_ARM_HalfDifference:
- case macho::RIT_Pair:
- case macho::RIT_Difference:
- case macho::RIT_ARM_LocalDifference:
- case macho::RIT_ARM_PreboundLazyPointer:
+ case MachO::ARM_THUMB_RELOC_BR22:
+ case MachO::ARM_THUMB_32BIT_BRANCH:
+ case MachO::ARM_RELOC_HALF:
+ case MachO::ARM_RELOC_HALF_SECTDIFF:
+ case MachO::ARM_RELOC_PAIR:
+ case MachO::ARM_RELOC_SECTDIFF:
+ case MachO::ARM_RELOC_LOCAL_SECTDIFF:
+ case MachO::ARM_RELOC_PB_LA_PTR:
return Error("Relocation type not implemented yet!");
}
return false;
StubMap &Stubs) {
const ObjectFile *OF = Obj.getObjectFile();
const MachOObjectFile *MachO = static_cast<const MachOObjectFile*>(OF);
- macho::RelocationEntry RE = MachO->getRelocation(RelI.getRawDataRefImpl());
+ MachO::any_relocation_info RE= MachO->getRelocation(RelI.getRawDataRefImpl());
uint32_t RelType = MachO->getAnyRelocationType(RE);
Value.Addend = Addend - Addr;
}
- if (Arch == Triple::x86_64 && (RelType == macho::RIT_X86_64_GOT ||
- RelType == macho::RIT_X86_64_GOTLoad)) {
+ if (Arch == Triple::x86_64 && (RelType == MachO::X86_64_RELOC_GOT ||
+ RelType == MachO::X86_64_RELOC_GOT_LOAD)) {
assert(IsPCRel);
assert(Size == 2);
StubMap::const_iterator i = Stubs.find(Value);
Stubs[Value] = Section.StubOffset;
uint8_t *GOTEntry = Section.Address + Section.StubOffset;
RelocationEntry RE(SectionID, Section.StubOffset,
- macho::RIT_X86_64_Unsigned, 0, false, 3);
+ MachO::X86_64_RELOC_UNSIGNED, 0, false, 3);
if (Value.SymbolName)
addRelocationForSymbol(RE, Value.SymbolName);
else
Addr = GOTEntry;
}
resolveRelocation(Section, Offset, (uint64_t)Addr,
- macho::RIT_X86_64_Unsigned, Value.Addend, true, 2);
+ MachO::X86_64_RELOC_UNSIGNED, Value.Addend, true, 2);
} else if (Arch == Triple::arm &&
- (RelType & 0xf) == macho::RIT_ARM_Branch24Bit) {
+ (RelType & 0xf) == MachO::ARM_RELOC_BR24) {
// This is an ARM branch relocation, need to use a stub function.
// Look up for existing stub.
uint8_t *StubTargetAddr = createStubFunction(Section.Address +
Section.StubOffset);
RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
- macho::RIT_Vanilla, Value.Addend);
+ MachO::GENERIC_RELOC_VANILLA, Value.Addend);
if (Value.SymbolName)
addRelocationForSymbol(RE, Value.SymbolName);
else
// Look for LC_MAIN.
{
- uint32_t LoadCommandCount = MOOF.getHeader().NumLoadCommands;
+ uint32_t LoadCommandCount = MOOF.getHeader().ncmds;
MachOObjectFile::LoadCommandInfo Load = MOOF.getFirstLoadCommandInfo();
for (unsigned I = 0;; ++I) {
- if (Load.C.Type == MachO::LC_MAIN) {
+ if (Load.C.cmd == MachO::LC_MAIN) {
EntryFileOffset =
((const MachO::entry_point_command *)Load.Ptr)->entryoff;
break;
if (Name == "__stubs") {
SectionRef StubsSec = *SI;
if (MOOF->is64Bit()) {
- macho::Section64 S = MOOF->getSection64(StubsSec.getRawDataRefImpl());
- StubsIndSymIndex = S.Reserved1;
- StubSize = S.Reserved2;
+ MachO::section_64 S = MOOF->getSection64(StubsSec.getRawDataRefImpl());
+ StubsIndSymIndex = S.reserved1;
+ StubSize = S.reserved2;
} else {
- macho::Section S = MOOF->getSection(StubsSec.getRawDataRefImpl());
- StubsIndSymIndex = S.Reserved1;
- StubSize = S.Reserved2;
+ MachO::section S = MOOF->getSection(StubsSec.getRawDataRefImpl());
+ StubsIndSymIndex = S.reserved1;
+ StubSize = S.reserved2;
}
assert(StubSize && "Mach-O stub entry size can't be zero!");
StubsSec.getAddress(StubsStart);
if (StubIdx >= StubsCount)
return StringRef();
- macho::IndirectSymbolTableEntry ISTE =
+ uint32_t SymtabIdx =
MOOF->getIndirectSymbolTableEntry(MOOF->getDysymtabLoadCommand(), StubIdx);
- uint32_t SymtabIdx = ISTE.Index;
StringRef SymName;
symbol_iterator SI = MOOF->begin_symbols();
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCValue.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MachO.h"
#include <vector>
using namespace llvm;
-using namespace llvm::object;
void MachObjectWriter::reset() {
Relocations.clear();
uint32_t Flags = 0;
if (SubsectionsViaSymbols)
- Flags |= macho::HF_SubsectionsViaSymbols;
+ Flags |= MachO::MH_SUBSECTIONS_VIA_SYMBOLS;
// struct mach_header (28 bytes) or
// struct mach_header_64 (32 bytes)
uint64_t Start = OS.tell();
(void) Start;
- Write32(is64Bit() ? macho::HM_Object64 : macho::HM_Object32);
+ Write32(is64Bit() ? MachO::MH_MAGIC_64 : MachO::MH_MAGIC);
Write32(TargetObjectWriter->getCPUType());
Write32(TargetObjectWriter->getCPUSubtype());
- Write32(macho::HFT_Object);
+ Write32(MachO::MH_OBJECT);
Write32(NumLoadCommands);
Write32(LoadCommandsSize);
Write32(Flags);
Write32(0); // reserved
assert(OS.tell() - Start ==
- (is64Bit() ? macho::Header64Size : macho::Header32Size));
+ (is64Bit()?sizeof(MachO::mach_header_64): sizeof(MachO::mach_header)));
}
/// WriteSegmentLoadCommand - Write a segment load command.
(void) Start;
unsigned SegmentLoadCommandSize =
- is64Bit() ? macho::SegmentLoadCommand64Size:
- macho::SegmentLoadCommand32Size;
- Write32(is64Bit() ? macho::LCT_Segment64 : macho::LCT_Segment);
+ is64Bit() ? sizeof(MachO::segment_command_64):
+ sizeof(MachO::segment_command);
+ Write32(is64Bit() ? MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT);
Write32(SegmentLoadCommandSize +
- NumSections * (is64Bit() ? macho::Section64Size :
- macho::Section32Size));
+ NumSections * (is64Bit() ? sizeof(MachO::section_64) :
+ sizeof(MachO::section)));
WriteBytes("", 16);
if (is64Bit()) {
if (is64Bit())
Write32(0); // reserved3
- assert(OS.tell() - Start == (is64Bit() ? macho::Section64Size :
- macho::Section32Size));
+ assert(OS.tell() - Start == (is64Bit() ? sizeof(MachO::section_64) :
+ sizeof(MachO::section)));
}
void MachObjectWriter::WriteSymtabLoadCommand(uint32_t SymbolOffset,
uint64_t Start = OS.tell();
(void) Start;
- Write32(macho::LCT_Symtab);
- Write32(macho::SymtabLoadCommandSize);
+ Write32(MachO::LC_SYMTAB);
+ Write32(sizeof(MachO::symtab_command));
Write32(SymbolOffset);
Write32(NumSymbols);
Write32(StringTableOffset);
Write32(StringTableSize);
- assert(OS.tell() - Start == macho::SymtabLoadCommandSize);
+ assert(OS.tell() - Start == sizeof(MachO::symtab_command));
}
void MachObjectWriter::WriteDysymtabLoadCommand(uint32_t FirstLocalSymbol,
uint64_t Start = OS.tell();
(void) Start;
- Write32(macho::LCT_Dysymtab);
- Write32(macho::DysymtabLoadCommandSize);
+ Write32(MachO::LC_DYSYMTAB);
+ Write32(sizeof(MachO::dysymtab_command));
Write32(FirstLocalSymbol);
Write32(NumLocalSymbols);
Write32(FirstExternalSymbol);
Write32(0); // locreloff
Write32(0); // nlocrel
- assert(OS.tell() - Start == macho::DysymtabLoadCommandSize);
+ assert(OS.tell() - Start == sizeof(MachO::dysymtab_command));
}
void MachObjectWriter::WriteNlist(MachSymbolData &MSD,
//
// FIXME: Are the prebound or indirect fields possible here?
if (Symbol.isUndefined())
- Type = macho::STT_Undefined;
+ Type = MachO::N_UNDF;
else if (Symbol.isAbsolute())
- Type = macho::STT_Absolute;
+ Type = MachO::N_ABS;
else
- Type = macho::STT_Section;
+ Type = MachO::N_SECT;
// FIXME: Set STAB bits.
if (Data.isPrivateExtern())
- Type |= macho::STF_PrivateExtern;
+ Type |= MachO::N_PEXT;
// Set external bit.
if (Data.isExternal() || Symbol.isUndefined())
- Type |= macho::STF_External;
+ Type |= MachO::N_EXT;
// Compute the symbol address.
if (Symbol.isDefined()) {
(void) Start;
Write32(Type);
- Write32(macho::LinkeditLoadCommandSize);
+ Write32(sizeof(MachO::linkedit_data_command));
Write32(DataOffset);
Write32(DataSize);
- assert(OS.tell() - Start == macho::LinkeditLoadCommandSize);
+ assert(OS.tell() - Start == sizeof(MachO::linkedit_data_command));
}
static unsigned ComputeLinkerOptionsLoadCommandSize(
const std::vector<std::string> &Options, bool is64Bit)
{
- unsigned Size = sizeof(macho::LinkerOptionsLoadCommand);
+ unsigned Size = sizeof(MachO::linker_options_command);
for (unsigned i = 0, e = Options.size(); i != e; ++i)
Size += Options[i].size() + 1;
return RoundUpToAlignment(Size, is64Bit ? 8 : 4);
uint64_t Start = OS.tell();
(void) Start;
- Write32(macho::LCT_LinkerOptions);
+ Write32(MachO::LC_LINKER_OPTIONS);
Write32(Size);
Write32(Options.size());
- uint64_t BytesWritten = sizeof(macho::LinkerOptionsLoadCommand);
+ uint64_t BytesWritten = sizeof(MachO::linker_options_command);
for (unsigned i = 0, e = Options.size(); i != e; ++i) {
// Write each string, including the null byte.
const std::string &Option = Options[i];
// section headers) and the symbol table.
unsigned NumLoadCommands = 1;
uint64_t LoadCommandsSize = is64Bit() ?
- macho::SegmentLoadCommand64Size + NumSections * macho::Section64Size :
- macho::SegmentLoadCommand32Size + NumSections * macho::Section32Size;
+ sizeof(MachO::segment_command_64) + NumSections * sizeof(MachO::section_64):
+ sizeof(MachO::segment_command) + NumSections * sizeof(MachO::section);
// Add the data-in-code load command size, if used.
unsigned NumDataRegions = Asm.getDataRegions().size();
if (NumDataRegions) {
++NumLoadCommands;
- LoadCommandsSize += macho::LinkeditLoadCommandSize;
+ LoadCommandsSize += sizeof(MachO::linkedit_data_command);
}
// Add the symbol table load command sizes, if used.
UndefinedSymbolData.size();
if (NumSymbols) {
NumLoadCommands += 2;
- LoadCommandsSize += (macho::SymtabLoadCommandSize +
- macho::DysymtabLoadCommandSize);
+ LoadCommandsSize += (sizeof(MachO::symtab_command) +
+ sizeof(MachO::dysymtab_command));
}
// Add the linker option load commands sizes.
// Compute the total size of the section data, as well as its file size and vm
// size.
- uint64_t SectionDataStart = (is64Bit() ? macho::Header64Size :
- macho::Header32Size) + LoadCommandsSize;
+ uint64_t SectionDataStart = (is64Bit() ? sizeof(MachO::mach_header_64) :
+ sizeof(MachO::mach_header)) + LoadCommandsSize;
uint64_t SectionDataSize = 0;
uint64_t SectionDataFileSize = 0;
uint64_t VMSize = 0;
uint64_t RelocTableEnd = SectionDataStart + SectionDataFileSize;
for (MCAssembler::const_iterator it = Asm.begin(),
ie = Asm.end(); it != ie; ++it) {
- std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
+ std::vector<MachO::any_relocation_info> &Relocs = Relocations[it];
unsigned NumRelocs = Relocs.size();
uint64_t SectionStart = SectionDataStart + getSectionAddress(it);
WriteSection(Asm, Layout, *it, SectionStart, RelocTableEnd, NumRelocs);
- RelocTableEnd += NumRelocs * macho::RelocationInfoSize;
+ RelocTableEnd += NumRelocs * sizeof(MachO::any_relocation_info);
}
// Write the data-in-code load command, if used.
if (NumDataRegions) {
uint64_t DataRegionsOffset = RelocTableEnd;
uint64_t DataRegionsSize = NumDataRegions * 8;
- WriteLinkeditLoadCommand(macho::LCT_DataInCode, DataRegionsOffset,
+ WriteLinkeditLoadCommand(MachO::LC_DATA_IN_CODE, DataRegionsOffset,
DataRegionsSize);
}
// The string table is written after symbol table.
uint64_t StringTableOffset =
- SymbolTableOffset + NumSymTabSymbols * (is64Bit() ? macho::Nlist64Size :
- macho::Nlist32Size);
+ SymbolTableOffset + NumSymTabSymbols * (is64Bit() ?
+ sizeof(MachO::nlist_64) :
+ sizeof(MachO::nlist));
WriteSymtabLoadCommand(SymbolTableOffset, NumSymTabSymbols,
StringTableOffset, StringTable.size());
ie = Asm.end(); it != ie; ++it) {
// Write the section relocation entries, in reverse order to match 'as'
// (approximately, the exact algorithm is more complicated than this).
- std::vector<macho::RelocationEntry> &Relocs = Relocations[it];
+ std::vector<MachO::any_relocation_info> &Relocs = Relocations[it];
for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
- Write32(Relocs[e - i - 1].Word0);
- Write32(Relocs[e - i - 1].Word1);
+ Write32(Relocs[e - i - 1].r_word0);
+ Write32(Relocs[e - i - 1].r_word1);
}
}
// If this symbol is defined and internal, mark it as such.
if (it->Symbol->isDefined() &&
!Asm.getSymbolData(*it->Symbol).isExternal()) {
- uint32_t Flags = macho::ISF_Local;
+ uint32_t Flags = MachO::INDIRECT_SYMBOL_LOCAL;
if (it->Symbol->isAbsolute())
- Flags |= macho::ISF_Absolute;
+ Flags |= MachO::INDIRECT_SYMBOL_ABS;
Write32(Flags);
continue;
}
#include "llvm/Object/MachO.h"
#include "llvm/ADT/Triple.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/DataExtractor.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/Host.h"
-#include "llvm/Support/MachO.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
#include <cctype>
namespace llvm {
namespace object {
-struct SymbolTableEntryBase {
- uint32_t StringIndex;
- uint8_t Type;
- uint8_t SectionIndex;
- uint16_t Flags;
+struct nlist_base {
+ uint32_t n_strx;
+ uint8_t n_type;
+ uint8_t n_sect;
+ uint16_t n_desc;
};
-struct SectionBase {
- char Name[16];
- char SegmentName[16];
+struct section_base {
+ char sectname[16];
+ char segname[16];
};
template<typename T>
static void SwapStruct(T &Value);
template<>
-void SwapStruct(macho::RelocationEntry &H) {
- SwapValue(H.Word0);
- SwapValue(H.Word1);
+void SwapStruct(MachO::any_relocation_info &H) {
+ SwapValue(H.r_word0);
+ SwapValue(H.r_word1);
}
template<>
-void SwapStruct(macho::LoadCommand &L) {
- SwapValue(L.Type);
- SwapValue(L.Size);
+void SwapStruct(MachO::load_command &L) {
+ SwapValue(L.cmd);
+ SwapValue(L.cmdsize);
}
template<>
-void SwapStruct(SymbolTableEntryBase &S) {
- SwapValue(S.StringIndex);
- SwapValue(S.Flags);
+void SwapStruct(nlist_base &S) {
+ SwapValue(S.n_strx);
+ SwapValue(S.n_desc);
}
template<>
-void SwapStruct(macho::Section &S) {
- SwapValue(S.Address);
- SwapValue(S.Size);
- SwapValue(S.Offset);
- SwapValue(S.Align);
- SwapValue(S.RelocationTableOffset);
- SwapValue(S.NumRelocationTableEntries);
- SwapValue(S.Flags);
- SwapValue(S.Reserved1);
- SwapValue(S.Reserved2);
+void SwapStruct(MachO::section &S) {
+ SwapValue(S.addr);
+ SwapValue(S.size);
+ SwapValue(S.offset);
+ SwapValue(S.align);
+ SwapValue(S.reloff);
+ SwapValue(S.nreloc);
+ SwapValue(S.flags);
+ SwapValue(S.reserved1);
+ SwapValue(S.reserved2);
}
template<>
-void SwapStruct(macho::Section64 &S) {
- SwapValue(S.Address);
- SwapValue(S.Size);
- SwapValue(S.Offset);
- SwapValue(S.Align);
- SwapValue(S.RelocationTableOffset);
- SwapValue(S.NumRelocationTableEntries);
- SwapValue(S.Flags);
- SwapValue(S.Reserved1);
- SwapValue(S.Reserved2);
- SwapValue(S.Reserved3);
+void SwapStruct(MachO::section_64 &S) {
+ SwapValue(S.addr);
+ SwapValue(S.size);
+ SwapValue(S.offset);
+ SwapValue(S.align);
+ SwapValue(S.reloff);
+ SwapValue(S.nreloc);
+ SwapValue(S.flags);
+ SwapValue(S.reserved1);
+ SwapValue(S.reserved2);
+ SwapValue(S.reserved3);
}
template<>
-void SwapStruct(macho::SymbolTableEntry &S) {
- SwapValue(S.StringIndex);
- SwapValue(S.Flags);
- SwapValue(S.Value);
+void SwapStruct(MachO::nlist &S) {
+ SwapValue(S.n_strx);
+ SwapValue(S.n_desc);
+ SwapValue(S.n_value);
}
template<>
-void SwapStruct(macho::Symbol64TableEntry &S) {
- SwapValue(S.StringIndex);
- SwapValue(S.Flags);
- SwapValue(S.Value);
+void SwapStruct(MachO::nlist_64 &S) {
+ SwapValue(S.n_strx);
+ SwapValue(S.n_desc);
+ SwapValue(S.n_value);
}
template<>
-void SwapStruct(macho::Header &H) {
- SwapValue(H.Magic);
- SwapValue(H.CPUType);
- SwapValue(H.CPUSubtype);
- SwapValue(H.FileType);
- SwapValue(H.NumLoadCommands);
- SwapValue(H.SizeOfLoadCommands);
- SwapValue(H.Flags);
+void SwapStruct(MachO::mach_header &H) {
+ SwapValue(H.magic);
+ SwapValue(H.cputype);
+ SwapValue(H.cpusubtype);
+ SwapValue(H.filetype);
+ SwapValue(H.ncmds);
+ SwapValue(H.sizeofcmds);
+ SwapValue(H.flags);
}
template<>
-void SwapStruct(macho::Header64Ext &E) {
- SwapValue(E.Reserved);
+void SwapStruct(MachO::mach_header_64 &H) {
+ SwapValue(H.magic);
+ SwapValue(H.cputype);
+ SwapValue(H.cpusubtype);
+ SwapValue(H.filetype);
+ SwapValue(H.ncmds);
+ SwapValue(H.sizeofcmds);
+ SwapValue(H.flags);
+ SwapValue(H.reserved);
}
template<>
-void SwapStruct(macho::SymtabLoadCommand &C) {
- SwapValue(C.Type);
- SwapValue(C.Size);
- SwapValue(C.SymbolTableOffset);
- SwapValue(C.NumSymbolTableEntries);
- SwapValue(C.StringTableOffset);
- SwapValue(C.StringTableSize);
+void SwapStruct(MachO::symtab_command &C) {
+ SwapValue(C.cmd);
+ SwapValue(C.cmdsize);
+ SwapValue(C.symoff);
+ SwapValue(C.nsyms);
+ SwapValue(C.stroff);
+ SwapValue(C.strsize);
}
template<>
-void SwapStruct(macho::DysymtabLoadCommand &C) {
- SwapValue(C.Type);
- SwapValue(C.Size);
- SwapValue(C.LocalSymbolsIndex);
- SwapValue(C.NumLocalSymbols);
- SwapValue(C.ExternalSymbolsIndex);
- SwapValue(C.NumExternalSymbols);
- SwapValue(C.UndefinedSymbolsIndex);
- SwapValue(C.NumUndefinedSymbols);
- SwapValue(C.TOCOffset);
- SwapValue(C.NumTOCEntries);
- SwapValue(C.ModuleTableOffset);
- SwapValue(C.NumModuleTableEntries);
- SwapValue(C.ReferenceSymbolTableOffset);
- SwapValue(C.NumReferencedSymbolTableEntries);
- SwapValue(C.IndirectSymbolTableOffset);
- SwapValue(C.NumIndirectSymbolTableEntries);
- SwapValue(C.ExternalRelocationTableOffset);
- SwapValue(C.NumExternalRelocationTableEntries);
- SwapValue(C.LocalRelocationTableOffset);
- SwapValue(C.NumLocalRelocationTableEntries);
+void SwapStruct(MachO::dysymtab_command &C) {
+ SwapValue(C.cmd);
+ SwapValue(C.cmdsize);
+ SwapValue(C.ilocalsym);
+ SwapValue(C.nlocalsym);
+ SwapValue(C.iextdefsym);
+ SwapValue(C.nextdefsym);
+ SwapValue(C.iundefsym);
+ SwapValue(C.nundefsym);
+ SwapValue(C.tocoff);
+ SwapValue(C.ntoc);
+ SwapValue(C.modtaboff);
+ SwapValue(C.nmodtab);
+ SwapValue(C.extrefsymoff);
+ SwapValue(C.nextrefsyms);
+ SwapValue(C.indirectsymoff);
+ SwapValue(C.nindirectsyms);
+ SwapValue(C.extreloff);
+ SwapValue(C.nextrel);
+ SwapValue(C.locreloff);
+ SwapValue(C.nlocrel);
}
template<>
-void SwapStruct(macho::LinkeditDataLoadCommand &C) {
- SwapValue(C.Type);
- SwapValue(C.Size);
- SwapValue(C.DataOffset);
- SwapValue(C.DataSize);
+void SwapStruct(MachO::linkedit_data_command &C) {
+ SwapValue(C.cmd);
+ SwapValue(C.cmdsize);
+ SwapValue(C.dataoff);
+ SwapValue(C.datasize);
}
template<>
-void SwapStruct(macho::SegmentLoadCommand &C) {
- SwapValue(C.Type);
- SwapValue(C.Size);
- SwapValue(C.VMAddress);
- SwapValue(C.VMSize);
- SwapValue(C.FileOffset);
- SwapValue(C.FileSize);
- SwapValue(C.MaxVMProtection);
- SwapValue(C.InitialVMProtection);
- SwapValue(C.NumSections);
- SwapValue(C.Flags);
+void SwapStruct(MachO::segment_command &C) {
+ SwapValue(C.cmd);
+ SwapValue(C.cmdsize);
+ SwapValue(C.vmaddr);
+ SwapValue(C.vmsize);
+ SwapValue(C.fileoff);
+ SwapValue(C.filesize);
+ SwapValue(C.maxprot);
+ SwapValue(C.initprot);
+ SwapValue(C.nsects);
+ SwapValue(C.flags);
}
template<>
-void SwapStruct(macho::Segment64LoadCommand &C) {
- SwapValue(C.Type);
- SwapValue(C.Size);
- SwapValue(C.VMAddress);
- SwapValue(C.VMSize);
- SwapValue(C.FileOffset);
- SwapValue(C.FileSize);
- SwapValue(C.MaxVMProtection);
- SwapValue(C.InitialVMProtection);
- SwapValue(C.NumSections);
- SwapValue(C.Flags);
+void SwapStruct(MachO::segment_command_64 &C) {
+ SwapValue(C.cmd);
+ SwapValue(C.cmdsize);
+ SwapValue(C.vmaddr);
+ SwapValue(C.vmsize);
+ SwapValue(C.fileoff);
+ SwapValue(C.filesize);
+ SwapValue(C.maxprot);
+ SwapValue(C.initprot);
+ SwapValue(C.nsects);
+ SwapValue(C.flags);
}
template<>
-void SwapStruct(macho::IndirectSymbolTableEntry &C) {
- SwapValue(C.Index);
+void SwapStruct(uint32_t &C) {
+ SwapValue(C);
}
template<>
-void SwapStruct(macho::LinkerOptionsLoadCommand &C) {
- SwapValue(C.Type);
- SwapValue(C.Size);
- SwapValue(C.Count);
+void SwapStruct(MachO::linker_options_command &C) {
+ SwapValue(C.cmd);
+ SwapValue(C.cmdsize);
+ SwapValue(C.count);
}
template<>
-void SwapStruct(macho::DataInCodeTableEntry &C) {
- SwapValue(C.Offset);
- SwapValue(C.Length);
- SwapValue(C.Kind);
+void SwapStruct(MachO::data_in_code_entry &C) {
+ SwapValue(C.offset);
+ SwapValue(C.length);
+ SwapValue(C.kind);
}
template<typename T>
getSegmentLoadCommandNumSections(const MachOObjectFile *O,
const MachOObjectFile::LoadCommandInfo &L) {
if (O->is64Bit()) {
- macho::Segment64LoadCommand S = O->getSegment64LoadCommand(L);
- return S.NumSections;
+ MachO::segment_command_64 S = O->getSegment64LoadCommand(L);
+ return S.nsects;
}
- macho::SegmentLoadCommand S = O->getSegmentLoadCommand(L);
- return S.NumSections;
+ MachO::segment_command S = O->getSegmentLoadCommand(L);
+ return S.nsects;
}
static const char *
uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr);
bool Is64 = O->is64Bit();
- unsigned SegmentLoadSize = Is64 ? sizeof(macho::Segment64LoadCommand) :
- sizeof(macho::SegmentLoadCommand);
- unsigned SectionSize = Is64 ? sizeof(macho::Section64) :
- sizeof(macho::Section);
+ unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) :
+ sizeof(MachO::segment_command);
+ unsigned SectionSize = Is64 ? sizeof(MachO::section_64) :
+ sizeof(MachO::section);
uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize;
return reinterpret_cast<const char*>(SectionAddr);
return O->getData().substr(Offset, 1).data();
}
-static SymbolTableEntryBase
+static nlist_base
getSymbolTableEntryBase(const MachOObjectFile *O, DataRefImpl DRI) {
const char *P = reinterpret_cast<const char *>(DRI.p);
- return getStruct<SymbolTableEntryBase>(O, P);
+ return getStruct<nlist_base>(O, P);
}
static StringRef parseSegmentOrSectionName(const char *P) {
}
static unsigned getCPUType(const MachOObjectFile *O) {
- return O->getHeader().CPUType;
+ return O->getHeader().cputype;
}
static void printRelocationTargetName(const MachOObjectFile *O,
- const macho::RelocationEntry &RE,
+ const MachO::any_relocation_info &RE,
raw_string_ostream &fmt) {
bool IsScattered = O->isRelocationScattered(RE);
fmt << S;
}
-static uint32_t getPlainRelocationAddress(const macho::RelocationEntry &RE) {
- return RE.Word0;
+static uint32_t
+getPlainRelocationAddress(const MachO::any_relocation_info &RE) {
+ return RE.r_word0;
}
static unsigned
-getScatteredRelocationAddress(const macho::RelocationEntry &RE) {
- return RE.Word0 & 0xffffff;
+getScatteredRelocationAddress(const MachO::any_relocation_info &RE) {
+ return RE.r_word0 & 0xffffff;
}
static bool getPlainRelocationPCRel(const MachOObjectFile *O,
- const macho::RelocationEntry &RE) {
+ const MachO::any_relocation_info &RE) {
if (O->isLittleEndian())
- return (RE.Word1 >> 24) & 1;
- return (RE.Word1 >> 7) & 1;
+ return (RE.r_word1 >> 24) & 1;
+ return (RE.r_word1 >> 7) & 1;
}
static bool
getScatteredRelocationPCRel(const MachOObjectFile *O,
- const macho::RelocationEntry &RE) {
- return (RE.Word0 >> 30) & 1;
+ const MachO::any_relocation_info &RE) {
+ return (RE.r_word0 >> 30) & 1;
}
static unsigned getPlainRelocationLength(const MachOObjectFile *O,
- const macho::RelocationEntry &RE) {
+ const MachO::any_relocation_info &RE) {
if (O->isLittleEndian())
- return (RE.Word1 >> 25) & 3;
- return (RE.Word1 >> 5) & 3;
+ return (RE.r_word1 >> 25) & 3;
+ return (RE.r_word1 >> 5) & 3;
}
static unsigned
-getScatteredRelocationLength(const macho::RelocationEntry &RE) {
- return (RE.Word0 >> 28) & 3;
+getScatteredRelocationLength(const MachO::any_relocation_info &RE) {
+ return (RE.r_word0 >> 28) & 3;
}
static unsigned getPlainRelocationType(const MachOObjectFile *O,
- const macho::RelocationEntry &RE) {
+ const MachO::any_relocation_info &RE) {
if (O->isLittleEndian())
- return RE.Word1 >> 28;
- return RE.Word1 & 0xf;
+ return RE.r_word1 >> 28;
+ return RE.r_word1 & 0xf;
}
-static unsigned getScatteredRelocationType(const macho::RelocationEntry &RE) {
- return (RE.Word0 >> 24) & 0xf;
+static unsigned
+getScatteredRelocationType(const MachO::any_relocation_info &RE) {
+ return (RE.r_word0 >> 24) & 0xf;
}
static uint32_t getSectionFlags(const MachOObjectFile *O,
DataRefImpl Sec) {
if (O->is64Bit()) {
- macho::Section64 Sect = O->getSection64(Sec);
- return Sect.Flags;
+ MachO::section_64 Sect = O->getSection64(Sec);
+ return Sect.flags;
}
- macho::Section Sect = O->getSection(Sec);
- return Sect.Flags;
+ MachO::section Sect = O->getSection(Sec);
+ return Sect.flags;
}
MachOObjectFile::MachOObjectFile(MemoryBuffer *Object,
error_code &ec)
: ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object),
SymtabLoadCmd(NULL), DysymtabLoadCmd(NULL), DataInCodeLoadCmd(NULL) {
- uint32_t LoadCommandCount = this->getHeader().NumLoadCommands;
- macho::LoadCommandType SegmentLoadType = is64Bit() ?
- macho::LCT_Segment64 : macho::LCT_Segment;
+ uint32_t LoadCommandCount = this->getHeader().ncmds;
+ MachO::LoadCommandType SegmentLoadType = is64Bit() ?
+ MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT;
MachOObjectFile::LoadCommandInfo Load = getFirstLoadCommandInfo();
for (unsigned I = 0; ; ++I) {
- if (Load.C.Type == macho::LCT_Symtab) {
+ if (Load.C.cmd == MachO::LC_SYMTAB) {
assert(!SymtabLoadCmd && "Multiple symbol tables");
SymtabLoadCmd = Load.Ptr;
- } else if (Load.C.Type == macho::LCT_Dysymtab) {
+ } else if (Load.C.cmd == MachO::LC_DYSYMTAB) {
assert(!DysymtabLoadCmd && "Multiple dynamic symbol tables");
DysymtabLoadCmd = Load.Ptr;
- } else if (Load.C.Type == macho::LCT_DataInCode) {
+ } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) {
assert(!DataInCodeLoadCmd && "Multiple data in code tables");
DataInCodeLoadCmd = Load.Ptr;
- } else if (Load.C.Type == SegmentLoadType) {
+ } else if (Load.C.cmd == SegmentLoadType) {
uint32_t NumSections = getSegmentLoadCommandNumSections(this, Load);
for (unsigned J = 0; J < NumSections; ++J) {
const char *Sec = getSectionPtr(this, Load, J);
error_code MachOObjectFile::getSymbolNext(DataRefImpl Symb,
SymbolRef &Res) const {
unsigned SymbolTableEntrySize = is64Bit() ?
- sizeof(macho::Symbol64TableEntry) :
- sizeof(macho::SymbolTableEntry);
+ sizeof(MachO::nlist_64) :
+ sizeof(MachO::nlist);
Symb.p += SymbolTableEntrySize;
Res = SymbolRef(Symb, this);
return object_error::success;
error_code MachOObjectFile::getSymbolName(DataRefImpl Symb,
StringRef &Res) const {
StringRef StringTable = getStringTableData();
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb);
- const char *Start = &StringTable.data()[Entry.StringIndex];
+ nlist_base Entry = getSymbolTableEntryBase(this, Symb);
+ const char *Start = &StringTable.data()[Entry.n_strx];
Res = StringRef(Start);
return object_error::success;
}
error_code MachOObjectFile::getSymbolAddress(DataRefImpl Symb,
uint64_t &Res) const {
if (is64Bit()) {
- macho::Symbol64TableEntry Entry = getSymbol64TableEntry(Symb);
- Res = Entry.Value;
+ MachO::nlist_64 Entry = getSymbol64TableEntry(Symb);
+ Res = Entry.n_value;
} else {
- macho::SymbolTableEntry Entry = getSymbolTableEntry(Symb);
- Res = Entry.Value;
+ MachO::nlist Entry = getSymbolTableEntry(Symb);
+ Res = Entry.n_value;
}
return object_error::success;
}
error_code
MachOObjectFile::getSymbolFileOffset(DataRefImpl Symb,
uint64_t &Res) const {
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb);
+ nlist_base Entry = getSymbolTableEntryBase(this, Symb);
getSymbolAddress(Symb, Res);
- if (Entry.SectionIndex) {
+ if (Entry.n_sect) {
uint64_t Delta;
DataRefImpl SecRel;
- SecRel.d.a = Entry.SectionIndex-1;
+ SecRel.d.a = Entry.n_sect-1;
if (is64Bit()) {
- macho::Section64 Sec = getSection64(SecRel);
- Delta = Sec.Offset - Sec.Address;
+ MachO::section_64 Sec = getSection64(SecRel);
+ Delta = Sec.offset - Sec.addr;
} else {
- macho::Section Sec = getSection(SecRel);
- Delta = Sec.Offset - Sec.Address;
+ MachO::section Sec = getSection(SecRel);
+ Delta = Sec.offset - Sec.addr;
}
Res += Delta;
uint32_t flags;
this->getSymbolFlags(DRI, flags);
if (flags & SymbolRef::SF_Common) {
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, DRI);
- Result = 1 << MachO::GET_COMM_ALIGN(Entry.Flags);
+ nlist_base Entry = getSymbolTableEntryBase(this, DRI);
+ Result = 1 << MachO::GET_COMM_ALIGN(Entry.n_desc);
} else {
Result = 0;
}
uint64_t EndOffset = 0;
uint8_t SectionIndex;
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, DRI);
+ nlist_base Entry = getSymbolTableEntryBase(this, DRI);
uint64_t Value;
getSymbolAddress(DRI, Value);
BeginOffset = Value;
- SectionIndex = Entry.SectionIndex;
+ SectionIndex = Entry.n_sect;
if (!SectionIndex) {
uint32_t flags = SymbolRef::SF_None;
this->getSymbolFlags(DRI, flags);
DataRefImpl DRI = I->getRawDataRefImpl();
Entry = getSymbolTableEntryBase(this, DRI);
getSymbolAddress(DRI, Value);
- if (Entry.SectionIndex == SectionIndex && Value > BeginOffset)
+ if (Entry.n_sect == SectionIndex && Value > BeginOffset)
if (!EndOffset || Value < EndOffset)
EndOffset = Value;
}
error_code MachOObjectFile::getSymbolType(DataRefImpl Symb,
SymbolRef::Type &Res) const {
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb);
- uint8_t n_type = Entry.Type;
+ nlist_base Entry = getSymbolTableEntryBase(this, Symb);
+ uint8_t n_type = Entry.n_type;
Res = SymbolRef::ST_Other;
error_code MachOObjectFile::getSymbolNMTypeChar(DataRefImpl Symb,
char &Res) const {
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb);
- uint8_t Type = Entry.Type;
- uint16_t Flags = Entry.Flags;
+ nlist_base Entry = getSymbolTableEntryBase(this, Symb);
+ uint8_t Type = Entry.n_type;
+ uint16_t Flags = Entry.n_desc;
char Char;
- switch (Type & macho::STF_TypeMask) {
- case macho::STT_Undefined:
+ switch (Type & MachO::N_TYPE) {
+ case MachO::N_UNDF:
Char = 'u';
break;
- case macho::STT_Absolute:
- case macho::STT_Section:
+ case MachO::N_ABS:
+ case MachO::N_SECT:
Char = 's';
break;
default:
break;
}
- if (Flags & (macho::STF_External | macho::STF_PrivateExtern))
+ if (Flags & (MachO::N_EXT | MachO::N_PEXT))
Char = toupper(static_cast<unsigned char>(Char));
Res = Char;
return object_error::success;
error_code MachOObjectFile::getSymbolFlags(DataRefImpl DRI,
uint32_t &Result) const {
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, DRI);
+ nlist_base Entry = getSymbolTableEntryBase(this, DRI);
- uint8_t MachOType = Entry.Type;
- uint16_t MachOFlags = Entry.Flags;
+ uint8_t MachOType = Entry.n_type;
+ uint16_t MachOFlags = Entry.n_desc;
// TODO: Correctly set SF_ThreadLocal
Result = SymbolRef::SF_None;
if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF)
Result |= SymbolRef::SF_Undefined;
- if (MachOFlags & macho::STF_StabsEntryMask)
+ if (MachOFlags & MachO::N_STAB)
Result |= SymbolRef::SF_FormatSpecific;
if (MachOType & MachO::N_EXT) {
error_code
MachOObjectFile::getSymbolSection(DataRefImpl Symb,
section_iterator &Res) const {
- SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb);
- uint8_t index = Entry.SectionIndex;
+ nlist_base Entry = getSymbolTableEntryBase(this, Symb);
+ uint8_t index = Entry.n_sect;
if (index == 0) {
Res = end_sections();
error_code
MachOObjectFile::getSectionAddress(DataRefImpl Sec, uint64_t &Res) const {
if (is64Bit()) {
- macho::Section64 Sect = getSection64(Sec);
- Res = Sect.Address;
+ MachO::section_64 Sect = getSection64(Sec);
+ Res = Sect.addr;
} else {
- macho::Section Sect = getSection(Sec);
- Res = Sect.Address;
+ MachO::section Sect = getSection(Sec);
+ Res = Sect.addr;
}
return object_error::success;
}
error_code
MachOObjectFile::getSectionSize(DataRefImpl Sec, uint64_t &Res) const {
if (is64Bit()) {
- macho::Section64 Sect = getSection64(Sec);
- Res = Sect.Size;
+ MachO::section_64 Sect = getSection64(Sec);
+ Res = Sect.size;
} else {
- macho::Section Sect = getSection(Sec);
- Res = Sect.Size;
+ MachO::section Sect = getSection(Sec);
+ Res = Sect.size;
}
return object_error::success;
uint64_t Size;
if (is64Bit()) {
- macho::Section64 Sect = getSection64(Sec);
- Offset = Sect.Offset;
- Size = Sect.Size;
+ MachO::section_64 Sect = getSection64(Sec);
+ Offset = Sect.offset;
+ Size = Sect.size;
} else {
- macho::Section Sect =getSection(Sec);
- Offset = Sect.Offset;
- Size = Sect.Size;
+ MachO::section Sect = getSection(Sec);
+ Offset = Sect.offset;
+ Size = Sect.size;
}
Res = this->getData().substr(Offset, Size);
MachOObjectFile::getSectionAlignment(DataRefImpl Sec, uint64_t &Res) const {
uint32_t Align;
if (is64Bit()) {
- macho::Section64 Sect = getSection64(Sec);
- Align = Sect.Align;
+ MachO::section_64 Sect = getSection64(Sec);
+ Align = Sect.align;
} else {
- macho::Section Sect = getSection(Sec);
- Align = Sect.Align;
+ MachO::section Sect = getSection(Sec);
+ Align = Sect.align;
}
Res = uint64_t(1) << Align;
error_code
MachOObjectFile::isSectionText(DataRefImpl Sec, bool &Res) const {
uint32_t Flags = getSectionFlags(this, Sec);
- Res = Flags & macho::SF_PureInstructions;
+ Res = Flags & MachO::S_ATTR_PURE_INSTRUCTIONS;
return object_error::success;
}
relocation_iterator MachOObjectFile::getSectionRelBegin(DataRefImpl Sec) const {
uint32_t Offset;
if (is64Bit()) {
- macho::Section64 Sect = getSection64(Sec);
- Offset = Sect.RelocationTableOffset;
+ MachO::section_64 Sect = getSection64(Sec);
+ Offset = Sect.reloff;
} else {
- macho::Section Sect = getSection(Sec);
- Offset = Sect.RelocationTableOffset;
+ MachO::section Sect = getSection(Sec);
+ Offset = Sect.reloff;
}
DataRefImpl Ret;
uint32_t Offset;
uint32_t Num;
if (is64Bit()) {
- macho::Section64 Sect = getSection64(Sec);
- Offset = Sect.RelocationTableOffset;
- Num = Sect.NumRelocationTableEntries;
+ MachO::section_64 Sect = getSection64(Sec);
+ Offset = Sect.reloff;
+ Num = Sect.nreloc;
} else {
- macho::Section Sect = getSection(Sec);
- Offset = Sect.RelocationTableOffset;
- Num = Sect.NumRelocationTableEntries;
+ MachO::section Sect = getSection(Sec);
+ Offset = Sect.reloff;
+ Num = Sect.nreloc;
}
- const macho::RelocationEntry *P =
- reinterpret_cast<const macho::RelocationEntry*>(getPtr(this, Offset));
+ const MachO::any_relocation_info *P =
+ reinterpret_cast<const MachO::any_relocation_info *>(getPtr(this, Offset));
DataRefImpl Ret;
Ret.p = reinterpret_cast<uintptr_t>(P + Num);
error_code MachOObjectFile::getRelocationNext(DataRefImpl Rel,
RelocationRef &Res) const {
- const macho::RelocationEntry *P =
- reinterpret_cast<const macho::RelocationEntry *>(Rel.p);
+ const MachO::any_relocation_info *P =
+ reinterpret_cast<const MachO::any_relocation_info *>(Rel.p);
Rel.p = reinterpret_cast<uintptr_t>(P + 1);
Res = RelocationRef(Rel, this);
return object_error::success;
error_code MachOObjectFile::getRelocationOffset(DataRefImpl Rel,
uint64_t &Res) const {
- macho::RelocationEntry RE = getRelocation(Rel);
+ MachO::any_relocation_info RE = getRelocation(Rel);
Res = getAnyRelocationAddress(RE);
return object_error::success;
}
symbol_iterator
MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const {
- macho::RelocationEntry RE = getRelocation(Rel);
+ MachO::any_relocation_info RE = getRelocation(Rel);
uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE);
bool isExtern = getPlainRelocationExternal(RE);
if (!isExtern)
return end_symbols();
- macho::SymtabLoadCommand S = getSymtabLoadCommand();
+ MachO::symtab_command S = getSymtabLoadCommand();
unsigned SymbolTableEntrySize = is64Bit() ?
- sizeof(macho::Symbol64TableEntry) :
- sizeof(macho::SymbolTableEntry);
- uint64_t Offset = S.SymbolTableOffset + SymbolIdx * SymbolTableEntrySize;
+ sizeof(MachO::nlist_64) :
+ sizeof(MachO::nlist);
+ uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize;
DataRefImpl Sym;
Sym.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
return symbol_iterator(SymbolRef(Sym, this));
error_code MachOObjectFile::getRelocationType(DataRefImpl Rel,
uint64_t &Res) const {
- macho::RelocationEntry RE = getRelocation(Rel);
+ MachO::any_relocation_info RE = getRelocation(Rel);
Res = getAnyRelocationType(RE);
return object_error::success;
}
error_code
MachOObjectFile::getRelocationValueString(DataRefImpl Rel,
SmallVectorImpl<char> &Result) const {
- macho::RelocationEntry RE = getRelocation(Rel);
+ MachO::any_relocation_info RE = getRelocation(Rel);
unsigned Arch = this->getArch();
bool isPCRel = getAnyRelocationPCRel(RE);
switch (Type) {
- case macho::RIT_X86_64_GOTLoad: // X86_64_RELOC_GOT_LOAD
- case macho::RIT_X86_64_GOT: { // X86_64_RELOC_GOT
+ case MachO::X86_64_RELOC_GOT_LOAD:
+ case MachO::X86_64_RELOC_GOT: {
printRelocationTargetName(this, RE, fmt);
fmt << "@GOT";
if (isPCRel) fmt << "PCREL";
break;
}
- case macho::RIT_X86_64_Subtractor: { // X86_64_RELOC_SUBTRACTOR
+ case MachO::X86_64_RELOC_SUBTRACTOR: {
DataRefImpl RelNext = Rel;
RelNext.d.a++;
- macho::RelocationEntry RENext = getRelocation(RelNext);
+ MachO::any_relocation_info RENext = getRelocation(RelNext);
- // X86_64_SUBTRACTOR must be followed by a relocation of type
+ // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type
// X86_64_RELOC_UNSIGNED.
// NOTE: Scattered relocations don't exist on x86_64.
unsigned RType = getAnyRelocationType(RENext);
- if (RType != 0)
+ if (RType != MachO::X86_64_RELOC_UNSIGNED)
report_fatal_error("Expected X86_64_RELOC_UNSIGNED after "
"X86_64_RELOC_SUBTRACTOR.");
- // The X86_64_RELOC_UNSIGNED contains the minuend symbol,
- // X86_64_SUBTRACTOR contains to the subtrahend.
+ // The X86_64_RELOC_UNSIGNED contains the minuend symbol;
+ // X86_64_RELOC_SUBTRACTOR contains the subtrahend.
printRelocationTargetName(this, RENext, fmt);
fmt << "-";
printRelocationTargetName(this, RE, fmt);
break;
}
- case macho::RIT_X86_64_TLV:
+ case MachO::X86_64_RELOC_TLV:
printRelocationTargetName(this, RE, fmt);
fmt << "@TLV";
if (isPCRel) fmt << "P";
break;
- case macho::RIT_X86_64_Signed1: // X86_64_RELOC_SIGNED1
+ case MachO::X86_64_RELOC_SIGNED_1:
printRelocationTargetName(this, RE, fmt);
fmt << "-1";
break;
- case macho::RIT_X86_64_Signed2: // X86_64_RELOC_SIGNED2
+ case MachO::X86_64_RELOC_SIGNED_2:
printRelocationTargetName(this, RE, fmt);
fmt << "-2";
break;
- case macho::RIT_X86_64_Signed4: // X86_64_RELOC_SIGNED4
+ case MachO::X86_64_RELOC_SIGNED_4:
printRelocationTargetName(this, RE, fmt);
fmt << "-4";
break;
Arch == Triple::ppc) {
// Generic relocation types...
switch (Type) {
- case macho::RIT_Pair: // GENERIC_RELOC_PAIR - prints no info
+ case MachO::GENERIC_RELOC_PAIR: // prints no info
return object_error::success;
- case macho::RIT_Difference: { // GENERIC_RELOC_SECTDIFF
+ case MachO::GENERIC_RELOC_SECTDIFF: {
DataRefImpl RelNext = Rel;
RelNext.d.a++;
- macho::RelocationEntry RENext = getRelocation(RelNext);
+ MachO::any_relocation_info RENext = getRelocation(RelNext);
// X86 sect diff's must be followed by a relocation of type
// GENERIC_RELOC_PAIR.
unsigned RType = getAnyRelocationType(RENext);
- if (RType != 1)
+ if (RType != MachO::GENERIC_RELOC_PAIR)
report_fatal_error("Expected GENERIC_RELOC_PAIR after "
"GENERIC_RELOC_SECTDIFF.");
}
if (Arch == Triple::x86 || Arch == Triple::ppc) {
- // All X86 relocations that need special printing were already
- // handled in the generic code.
switch (Type) {
- case macho::RIT_Generic_LocalDifference:{// GENERIC_RELOC_LOCAL_SECTDIFF
+ case MachO::GENERIC_RELOC_LOCAL_SECTDIFF: {
DataRefImpl RelNext = Rel;
RelNext.d.a++;
- macho::RelocationEntry RENext = getRelocation(RelNext);
+ MachO::any_relocation_info RENext = getRelocation(RelNext);
// X86 sect diff's must be followed by a relocation of type
// GENERIC_RELOC_PAIR.
unsigned RType = getAnyRelocationType(RENext);
- if (RType != 1)
+ if (RType != MachO::GENERIC_RELOC_PAIR)
report_fatal_error("Expected GENERIC_RELOC_PAIR after "
"GENERIC_RELOC_LOCAL_SECTDIFF.");
printRelocationTargetName(this, RENext, fmt);
break;
}
- case macho::RIT_Generic_TLV: {
+ case MachO::GENERIC_RELOC_TLV: {
printRelocationTargetName(this, RE, fmt);
fmt << "@TLV";
if (IsPCRel) fmt << "P";
}
} else { // ARM-specific relocations
switch (Type) {
- case macho::RIT_ARM_Half: // ARM_RELOC_HALF
- case macho::RIT_ARM_HalfDifference: { // ARM_RELOC_HALF_SECTDIFF
+ case MachO::ARM_RELOC_HALF:
+ case MachO::ARM_RELOC_HALF_SECTDIFF: {
// Half relocations steal a bit from the length field to encode
// whether this is an upper16 or a lower16 relocation.
bool isUpper = getAnyRelocationLength(RE) >> 1;
DataRefImpl RelNext = Rel;
RelNext.d.a++;
- macho::RelocationEntry RENext = getRelocation(RelNext);
+ MachO::any_relocation_info RENext = getRelocation(RelNext);
// ARM half relocs must be followed by a relocation of type
// ARM_RELOC_PAIR.
unsigned RType = getAnyRelocationType(RENext);
- if (RType != 1)
+ if (RType != MachO::ARM_RELOC_PAIR)
report_fatal_error("Expected ARM_RELOC_PAIR after "
- "GENERIC_RELOC_HALF");
+ "ARM_RELOC_HALF");
// NOTE: The half of the target virtual address is stashed in the
// address field of the secondary relocation, but we can't reverse
// ARM_RELOC_HALF_SECTDIFF encodes the second section in the
// symbol/section pointer of the follow-on relocation.
- if (Type == macho::RIT_ARM_HalfDifference) {
+ if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) {
fmt << "-";
printRelocationTargetName(this, RENext, fmt);
}
// On arches that use the generic relocations, GENERIC_RELOC_PAIR
// is always hidden.
if (Arch == Triple::x86 || Arch == Triple::arm || Arch == Triple::ppc) {
- if (Type == macho::RIT_Pair) Result = true;
+ if (Type == MachO::GENERIC_RELOC_PAIR) Result = true;
} else if (Arch == Triple::x86_64) {
// On x86_64, X86_64_RELOC_UNSIGNED is hidden only when it follows
// an X86_64_RELOC_SUBTRACTOR.
- if (Type == macho::RIT_X86_64_Unsigned && Rel.d.a > 0) {
+ if (Type == MachO::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) {
DataRefImpl RelPrev = Rel;
RelPrev.d.a--;
uint64_t PrevType;
getRelocationType(RelPrev, PrevType);
- if (PrevType == macho::RIT_X86_64_Subtractor)
+ if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR)
Result = true;
}
}
if (!SymtabLoadCmd)
return symbol_iterator(SymbolRef(DRI, this));
- macho::SymtabLoadCommand Symtab = getSymtabLoadCommand();
- DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.SymbolTableOffset));
+ MachO::symtab_command Symtab = getSymtabLoadCommand();
+ DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff));
return symbol_iterator(SymbolRef(DRI, this));
}
if (!SymtabLoadCmd)
return symbol_iterator(SymbolRef(DRI, this));
- macho::SymtabLoadCommand Symtab = getSymtabLoadCommand();
+ MachO::symtab_command Symtab = getSymtabLoadCommand();
unsigned SymbolTableEntrySize = is64Bit() ?
- sizeof(macho::Symbol64TableEntry) :
- sizeof(macho::SymbolTableEntry);
- unsigned Offset = Symtab.SymbolTableOffset +
- Symtab.NumSymbolTableEntries * SymbolTableEntrySize;
+ sizeof(MachO::nlist_64) :
+ sizeof(MachO::nlist);
+ unsigned Offset = Symtab.symoff +
+ Symtab.nsyms * SymbolTableEntrySize;
DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
return symbol_iterator(SymbolRef(DRI, this));
}
if (!DataInCodeLoadCmd)
return dice_iterator(DiceRef(DRI, this));
- macho::LinkeditDataLoadCommand DicLC = getDataInCodeLoadCommand();
- DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.DataOffset));
+ MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
+ DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.dataoff));
return dice_iterator(DiceRef(DRI, this));
}
if (!DataInCodeLoadCmd)
return dice_iterator(DiceRef(DRI, this));
- macho::LinkeditDataLoadCommand DicLC = getDataInCodeLoadCommand();
- unsigned Offset = DicLC.DataOffset + DicLC.DataSize;
+ MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand();
+ unsigned Offset = DicLC.dataoff + DicLC.datasize;
DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset));
return dice_iterator(DiceRef(DRI, this));
}
ArrayRef<char>
MachOObjectFile::getSectionRawName(DataRefImpl Sec) const {
- const SectionBase *Base =
- reinterpret_cast<const SectionBase*>(Sections[Sec.d.a]);
- return ArrayRef<char>(Base->Name);
+ const section_base *Base =
+ reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
+ return ArrayRef<char>(Base->sectname);
}
ArrayRef<char>
MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const {
- const SectionBase *Base =
- reinterpret_cast<const SectionBase*>(Sections[Sec.d.a]);
- return ArrayRef<char>(Base->SegmentName);
+ const section_base *Base =
+ reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
+ return ArrayRef<char>(Base->segname);
}
bool
-MachOObjectFile::isRelocationScattered(const macho::RelocationEntry &RE)
+MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE)
const {
- if (getCPUType(this) == llvm::MachO::CPU_TYPE_X86_64)
+ if (getCPUType(this) == MachO::CPU_TYPE_X86_64)
return false;
- return getPlainRelocationAddress(RE) & macho::RF_Scattered;
+ return getPlainRelocationAddress(RE) & MachO::R_SCATTERED;
}
unsigned MachOObjectFile::getPlainRelocationSymbolNum(
- const macho::RelocationEntry &RE) const {
+ const MachO::any_relocation_info &RE) const {
if (isLittleEndian())
- return RE.Word1 & 0xffffff;
- return RE.Word1 >> 8;
+ return RE.r_word1 & 0xffffff;
+ return RE.r_word1 >> 8;
}
bool MachOObjectFile::getPlainRelocationExternal(
- const macho::RelocationEntry &RE) const {
+ const MachO::any_relocation_info &RE) const {
if (isLittleEndian())
- return (RE.Word1 >> 27) & 1;
- return (RE.Word1 >> 4) & 1;
+ return (RE.r_word1 >> 27) & 1;
+ return (RE.r_word1 >> 4) & 1;
}
bool MachOObjectFile::getScatteredRelocationScattered(
- const macho::RelocationEntry &RE) const {
- return RE.Word0 >> 31;
+ const MachO::any_relocation_info &RE) const {
+ return RE.r_word0 >> 31;
}
uint32_t MachOObjectFile::getScatteredRelocationValue(
- const macho::RelocationEntry &RE) const {
- return RE.Word1;
+ const MachO::any_relocation_info &RE) const {
+ return RE.r_word1;
}
unsigned MachOObjectFile::getAnyRelocationAddress(
- const macho::RelocationEntry &RE) const {
+ const MachO::any_relocation_info &RE) const {
if (isRelocationScattered(RE))
return getScatteredRelocationAddress(RE);
return getPlainRelocationAddress(RE);
}
-unsigned
-MachOObjectFile::getAnyRelocationPCRel(const macho::RelocationEntry &RE) const {
+unsigned MachOObjectFile::getAnyRelocationPCRel(
+ const MachO::any_relocation_info &RE) const {
if (isRelocationScattered(RE))
return getScatteredRelocationPCRel(this, RE);
return getPlainRelocationPCRel(this, RE);
}
unsigned MachOObjectFile::getAnyRelocationLength(
- const macho::RelocationEntry &RE) const {
+ const MachO::any_relocation_info &RE) const {
if (isRelocationScattered(RE))
return getScatteredRelocationLength(RE);
return getPlainRelocationLength(this, RE);
}
unsigned
-MachOObjectFile::getAnyRelocationType(const macho::RelocationEntry &RE) const {
+MachOObjectFile::getAnyRelocationType(
+ const MachO::any_relocation_info &RE) const {
if (isRelocationScattered(RE))
return getScatteredRelocationType(RE);
return getPlainRelocationType(this, RE);
}
SectionRef
-MachOObjectFile::getRelocationSection(const macho::RelocationEntry &RE) const {
+MachOObjectFile::getRelocationSection(
+ const MachO::any_relocation_info &RE) const {
if (isRelocationScattered(RE) || getPlainRelocationExternal(RE))
return *end_sections();
unsigned SecNum = getPlainRelocationSymbolNum(RE) - 1;
MachOObjectFile::getFirstLoadCommandInfo() const {
MachOObjectFile::LoadCommandInfo Load;
- unsigned HeaderSize = is64Bit() ? macho::Header64Size : macho::Header32Size;
+ unsigned HeaderSize = is64Bit() ? sizeof(MachO::mach_header_64) :
+ sizeof(MachO::mach_header);
Load.Ptr = getPtr(this, HeaderSize);
- Load.C = getStruct<macho::LoadCommand>(this, Load.Ptr);
+ Load.C = getStruct<MachO::load_command>(this, Load.Ptr);
return Load;
}
MachOObjectFile::LoadCommandInfo
MachOObjectFile::getNextLoadCommandInfo(const LoadCommandInfo &L) const {
MachOObjectFile::LoadCommandInfo Next;
- Next.Ptr = L.Ptr + L.C.Size;
- Next.C = getStruct<macho::LoadCommand>(this, Next.Ptr);
+ Next.Ptr = L.Ptr + L.C.cmdsize;
+ Next.C = getStruct<MachO::load_command>(this, Next.Ptr);
return Next;
}
-macho::Section MachOObjectFile::getSection(DataRefImpl DRI) const {
- return getStruct<macho::Section>(this, Sections[DRI.d.a]);
+MachO::section MachOObjectFile::getSection(DataRefImpl DRI) const {
+ return getStruct<MachO::section>(this, Sections[DRI.d.a]);
}
-macho::Section64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
- return getStruct<macho::Section64>(this, Sections[DRI.d.a]);
+MachO::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const {
+ return getStruct<MachO::section_64>(this, Sections[DRI.d.a]);
}
-macho::Section MachOObjectFile::getSection(const LoadCommandInfo &L,
+MachO::section MachOObjectFile::getSection(const LoadCommandInfo &L,
unsigned Index) const {
const char *Sec = getSectionPtr(this, L, Index);
- return getStruct<macho::Section>(this, Sec);
+ return getStruct<MachO::section>(this, Sec);
}
-macho::Section64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
- unsigned Index) const {
+MachO::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L,
+ unsigned Index) const {
const char *Sec = getSectionPtr(this, L, Index);
- return getStruct<macho::Section64>(this, Sec);
+ return getStruct<MachO::section_64>(this, Sec);
}
-macho::SymbolTableEntry
+MachO::nlist
MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const {
const char *P = reinterpret_cast<const char *>(DRI.p);
- return getStruct<macho::SymbolTableEntry>(this, P);
+ return getStruct<MachO::nlist>(this, P);
}
-macho::Symbol64TableEntry
+MachO::nlist_64
MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const {
const char *P = reinterpret_cast<const char *>(DRI.p);
- return getStruct<macho::Symbol64TableEntry>(this, P);
+ return getStruct<MachO::nlist_64>(this, P);
}
-macho::LinkeditDataLoadCommand MachOObjectFile::getLinkeditDataLoadCommand(
- const MachOObjectFile::LoadCommandInfo &L) const {
- return getStruct<macho::LinkeditDataLoadCommand>(this, L.Ptr);
+MachO::linkedit_data_command
+MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const {
+ return getStruct<MachO::linkedit_data_command>(this, L.Ptr);
}
-macho::SegmentLoadCommand
+MachO::segment_command
MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const {
- return getStruct<macho::SegmentLoadCommand>(this, L.Ptr);
+ return getStruct<MachO::segment_command>(this, L.Ptr);
}
-macho::Segment64LoadCommand
+MachO::segment_command_64
MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const {
- return getStruct<macho::Segment64LoadCommand>(this, L.Ptr);
+ return getStruct<MachO::segment_command_64>(this, L.Ptr);
}
-macho::LinkerOptionsLoadCommand
+MachO::linker_options_command
MachOObjectFile::getLinkerOptionsLoadCommand(const LoadCommandInfo &L) const {
- return getStruct<macho::LinkerOptionsLoadCommand>(this, L.Ptr);
+ return getStruct<MachO::linker_options_command>(this, L.Ptr);
}
-macho::RelocationEntry
+MachO::any_relocation_info
MachOObjectFile::getRelocation(DataRefImpl Rel) const {
const char *P = reinterpret_cast<const char *>(Rel.p);
- return getStruct<macho::RelocationEntry>(this, P);
+ return getStruct<MachO::any_relocation_info>(this, P);
}
-macho::DataInCodeTableEntry
+MachO::data_in_code_entry
MachOObjectFile::getDice(DataRefImpl Rel) const {
const char *P = reinterpret_cast<const char *>(Rel.p);
- return getStruct<macho::DataInCodeTableEntry>(this, P);
+ return getStruct<MachO::data_in_code_entry>(this, P);
}
-macho::Header MachOObjectFile::getHeader() const {
- return getStruct<macho::Header>(this, getPtr(this, 0));
+MachO::mach_header MachOObjectFile::getHeader() const {
+ return getStruct<MachO::mach_header>(this, getPtr(this, 0));
}
-macho::Header64Ext MachOObjectFile::getHeader64Ext() const {
- return
- getStruct<macho::Header64Ext>(this, getPtr(this, sizeof(macho::Header)));
+MachO::mach_header_64 MachOObjectFile::getHeader64() const {
+ return getStruct<MachO::mach_header_64>(this, getPtr(this, 0));
}
-macho::IndirectSymbolTableEntry MachOObjectFile::getIndirectSymbolTableEntry(
- const macho::DysymtabLoadCommand &DLC,
- unsigned Index) const {
- uint64_t Offset = DLC.IndirectSymbolTableOffset +
- Index * sizeof(macho::IndirectSymbolTableEntry);
- return getStruct<macho::IndirectSymbolTableEntry>(this, getPtr(this, Offset));
+uint32_t MachOObjectFile::getIndirectSymbolTableEntry(
+ const MachO::dysymtab_command &DLC,
+ unsigned Index) const {
+ uint64_t Offset = DLC.indirectsymoff + Index * sizeof(uint32_t);
+ return getStruct<uint32_t>(this, getPtr(this, Offset));
}
-macho::DataInCodeTableEntry
+MachO::data_in_code_entry
MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset,
unsigned Index) const {
- uint64_t Offset = DataOffset + Index * sizeof(macho::DataInCodeTableEntry);
- return getStruct<macho::DataInCodeTableEntry>(this, getPtr(this, Offset));
+ uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry);
+ return getStruct<MachO::data_in_code_entry>(this, getPtr(this, Offset));
}
-macho::SymtabLoadCommand MachOObjectFile::getSymtabLoadCommand() const {
- return getStruct<macho::SymtabLoadCommand>(this, SymtabLoadCmd);
+MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const {
+ return getStruct<MachO::symtab_command>(this, SymtabLoadCmd);
}
-macho::DysymtabLoadCommand MachOObjectFile::getDysymtabLoadCommand() const {
- return getStruct<macho::DysymtabLoadCommand>(this, DysymtabLoadCmd);
+MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const {
+ return getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd);
}
-macho::LinkeditDataLoadCommand
+MachO::linkedit_data_command
MachOObjectFile::getDataInCodeLoadCommand() const {
if (DataInCodeLoadCmd)
- return getStruct<macho::LinkeditDataLoadCommand>(this, DataInCodeLoadCmd);
+ return getStruct<MachO::linkedit_data_command>(this, DataInCodeLoadCmd);
// If there is no DataInCodeLoadCmd return a load command with zero'ed fields.
- macho::LinkeditDataLoadCommand Cmd;
- Cmd.Type = macho::LCT_DataInCode;
- Cmd.Size = macho::LinkeditLoadCommandSize;
- Cmd.DataOffset = 0;
- Cmd.DataSize = 0;
+ MachO::linkedit_data_command Cmd;
+ Cmd.cmd = MachO::LC_DATA_IN_CODE;
+ Cmd.cmdsize = sizeof(MachO::linkedit_data_command);
+ Cmd.dataoff = 0;
+ Cmd.datasize = 0;
return Cmd;
}
StringRef MachOObjectFile::getStringTableData() const {
- macho::SymtabLoadCommand S = getSymtabLoadCommand();
- return getData().substr(S.StringTableOffset, S.StringTableSize);
+ MachO::symtab_command S = getSymtabLoadCommand();
+ return getData().substr(S.stroff, S.strsize);
}
bool MachOObjectFile::is64Bit() const {
static void SwapStruct(T &Value);
template<>
-void SwapStruct(macho::FatHeader &H) {
- SwapValue(H.Magic);
- SwapValue(H.NumFatArch);
+void SwapStruct(MachO::fat_header &H) {
+ SwapValue(H.magic);
+ SwapValue(H.nfat_arch);
}
template<>
-void SwapStruct(macho::FatArchHeader &H) {
- SwapValue(H.CPUType);
- SwapValue(H.CPUSubtype);
- SwapValue(H.Offset);
- SwapValue(H.Size);
- SwapValue(H.Align);
+void SwapStruct(MachO::fat_arch &H) {
+ SwapValue(H.cputype);
+ SwapValue(H.cpusubtype);
+ SwapValue(H.offset);
+ SwapValue(H.size);
+ SwapValue(H.align);
}
template<typename T>
} else {
// Parse object header.
StringRef ParentData = Parent->getData();
- const char *HeaderPos = ParentData.begin() + macho::FatHeaderSize +
- Index * macho::FatArchHeaderSize;
- Header = getUniversalBinaryStruct<macho::FatArchHeader>(HeaderPos);
- if (ParentData.size() < Header.Offset + Header.Size) {
+ const char *HeaderPos = ParentData.begin() + sizeof(MachO::fat_header) +
+ Index * sizeof(MachO::fat_arch);
+ Header = getUniversalBinaryStruct<MachO::fat_arch>(HeaderPos);
+ if (ParentData.size() < Header.offset + Header.size) {
clear();
}
}
OwningPtr<ObjectFile> &Result) const {
if (Parent) {
StringRef ParentData = Parent->getData();
- StringRef ObjectData = ParentData.substr(Header.Offset, Header.Size);
+ StringRef ObjectData = ParentData.substr(Header.offset, Header.size);
std::string ObjectName =
Parent->getFileName().str() + ":" +
- Triple::getArchTypeName(MachOObjectFile::getArch(Header.CPUType));
+ Triple::getArchTypeName(MachOObjectFile::getArch(Header.cputype));
MemoryBuffer *ObjBuffer = MemoryBuffer::getMemBuffer(
ObjectData, ObjectName, false);
if (ObjectFile *Obj = ObjectFile::createMachOObjectFile(ObjBuffer)) {
error_code &ec)
: Binary(Binary::ID_MachOUniversalBinary, Source),
NumberOfObjects(0) {
- if (Source->getBufferSize() < macho::FatHeaderSize) {
+ if (Source->getBufferSize() < sizeof(MachO::fat_header)) {
ec = object_error::invalid_file_type;
return;
}
// Check for magic value and sufficient header size.
StringRef Buf = getData();
- macho::FatHeader H = getUniversalBinaryStruct<macho::FatHeader>(Buf.begin());
- NumberOfObjects = H.NumFatArch;
- uint32_t MinSize = macho::FatHeaderSize +
- macho::FatArchHeaderSize * NumberOfObjects;
- if (H.Magic != macho::HM_Universal || Buf.size() < MinSize) {
+ MachO::fat_header H= getUniversalBinaryStruct<MachO::fat_header>(Buf.begin());
+ NumberOfObjects = H.nfat_arch;
+ uint32_t MinSize = sizeof(MachO::fat_header) +
+ sizeof(MachO::fat_arch) * NumberOfObjects;
+ if (H.magic != MachO::FAT_MAGIC || Buf.size() < MinSize) {
ec = object_error::parse_failed;
return;
}
ec = object_error::success;
}
-static bool getCTMForArch(Triple::ArchType Arch, mach::CPUTypeMachine &CTM) {
+static bool getCTMForArch(Triple::ArchType Arch, MachO::CPUType &CTM) {
switch (Arch) {
- case Triple::x86: CTM = mach::CTM_i386; return true;
- case Triple::x86_64: CTM = mach::CTM_x86_64; return true;
- case Triple::arm: CTM = mach::CTM_ARM; return true;
- case Triple::sparc: CTM = mach::CTM_SPARC; return true;
- case Triple::ppc: CTM = mach::CTM_PowerPC; return true;
- case Triple::ppc64: CTM = mach::CTM_PowerPC64; return true;
+ case Triple::x86: CTM = MachO::CPU_TYPE_I386; return true;
+ case Triple::x86_64: CTM = MachO::CPU_TYPE_X86_64; return true;
+ case Triple::arm: CTM = MachO::CPU_TYPE_ARM; return true;
+ case Triple::sparc: CTM = MachO::CPU_TYPE_SPARC; return true;
+ case Triple::ppc: CTM = MachO::CPU_TYPE_POWERPC; return true;
+ case Triple::ppc64: CTM = MachO::CPU_TYPE_POWERPC64; return true;
default: return false;
}
}
error_code
MachOUniversalBinary::getObjectForArch(Triple::ArchType Arch,
OwningPtr<ObjectFile> &Result) const {
- mach::CPUTypeMachine CTM;
+ MachO::CPUType CTM;
if (!getCTMForArch(Arch, CTM))
return object_error::arch_not_found;
for (object_iterator I = begin_objects(), E = end_objects(); I != E; ++I) {
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCSubtargetInfo.h"
#include "llvm/MC/MCValue.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/ELF.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MachO.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
// FIXME: This should be in a separate file.
class DarwinARMAsmBackend : public ARMAsmBackend {
public:
- const object::mach::CPUSubtypeARM Subtype;
+ const MachO::CPUSubTypeARM Subtype;
DarwinARMAsmBackend(const Target &T, const StringRef TT,
- object::mach::CPUSubtypeARM st)
+ MachO::CPUSubTypeARM st)
: ARMAsmBackend(T, TT), Subtype(st) {
HasDataInCodeSupport = true;
}
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createARMMachObjectWriter(OS, /*Is64Bit=*/false,
- object::mach::CTM_ARM,
+ MachO::CPU_TYPE_ARM,
Subtype);
}
Triple TheTriple(TT);
if (TheTriple.isOSDarwin()) {
- object::mach::CPUSubtypeARM CS =
- StringSwitch<object::mach::CPUSubtypeARM>(TheTriple.getArchName())
- .Cases("armv4t", "thumbv4t", object::mach::CSARM_V4T)
- .Cases("armv5e", "thumbv5e",object::mach::CSARM_V5TEJ)
- .Cases("armv6", "thumbv6", object::mach::CSARM_V6)
- .Cases("armv6m", "thumbv6m", object::mach::CSARM_V6M)
- .Cases("armv7em", "thumbv7em", object::mach::CSARM_V7EM)
- .Cases("armv7f", "thumbv7f", object::mach::CSARM_V7F)
- .Cases("armv7k", "thumbv7k", object::mach::CSARM_V7K)
- .Cases("armv7m", "thumbv7m", object::mach::CSARM_V7M)
- .Cases("armv7s", "thumbv7s", object::mach::CSARM_V7S)
- .Default(object::mach::CSARM_V7);
+ MachO::CPUSubTypeARM CS =
+ StringSwitch<MachO::CPUSubTypeARM>(TheTriple.getArchName())
+ .Cases("armv4t", "thumbv4t", MachO::CPU_SUBTYPE_ARM_V4T)
+ .Cases("armv5e", "thumbv5e", MachO::CPU_SUBTYPE_ARM_V5TEJ)
+ .Cases("armv6", "thumbv6", MachO::CPU_SUBTYPE_ARM_V6)
+ .Cases("armv6m", "thumbv6m", MachO::CPU_SUBTYPE_ARM_V6M)
+ .Cases("armv7em", "thumbv7em", MachO::CPU_SUBTYPE_ARM_V7EM)
+ .Cases("armv7f", "thumbv7f", MachO::CPU_SUBTYPE_ARM_V7F)
+ .Cases("armv7k", "thumbv7k", MachO::CPU_SUBTYPE_ARM_V7K)
+ .Cases("armv7m", "thumbv7m", MachO::CPU_SUBTYPE_ARM_V7M)
+ .Cases("armv7s", "thumbv7s", MachO::CPU_SUBTYPE_ARM_V7S)
+ .Default(MachO::CPU_SUBTYPE_ARM_V7);
return new DarwinARMAsmBackend(T, TT, CS);
}
#include "llvm/MC/MCMachOSymbolFlags.h"
#include "llvm/MC/MCMachObjectWriter.h"
#include "llvm/MC/MCValue.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MachO.h"
using namespace llvm;
-using namespace llvm::object;
namespace {
class ARMMachObjectWriter : public MCMachObjectTargetWriter {
static bool getARMFixupKindMachOInfo(unsigned Kind, unsigned &RelocType,
unsigned &Log2Size) {
- RelocType = unsigned(macho::RIT_Vanilla);
+ RelocType = unsigned(MachO::ARM_RELOC_VANILLA);
Log2Size = ~0U;
switch (Kind) {
case ARM::fixup_arm_uncondbl:
case ARM::fixup_arm_condbl:
case ARM::fixup_arm_blx:
- RelocType = unsigned(macho::RIT_ARM_Branch24Bit);
+ RelocType = unsigned(MachO::ARM_RELOC_BR24);
// Report as 'long', even though that is not quite accurate.
Log2Size = llvm::Log2_32(4);
return true;
// Handle Thumb branches.
case ARM::fixup_arm_thumb_br:
- RelocType = unsigned(macho::RIT_ARM_ThumbBranch22Bit);
+ RelocType = unsigned(MachO::ARM_THUMB_RELOC_BR22);
Log2Size = llvm::Log2_32(2);
return true;
case ARM::fixup_t2_uncondbranch:
case ARM::fixup_arm_thumb_bl:
case ARM::fixup_arm_thumb_blx:
- RelocType = unsigned(macho::RIT_ARM_ThumbBranch22Bit);
+ RelocType = unsigned(MachO::ARM_THUMB_RELOC_BR22);
Log2Size = llvm::Log2_32(4);
return true;
// 1 - thumb instructions
case ARM::fixup_arm_movt_hi16:
case ARM::fixup_arm_movt_hi16_pcrel:
- RelocType = unsigned(macho::RIT_ARM_Half);
+ RelocType = unsigned(MachO::ARM_RELOC_HALF);
Log2Size = 1;
return true;
case ARM::fixup_t2_movt_hi16:
case ARM::fixup_t2_movt_hi16_pcrel:
- RelocType = unsigned(macho::RIT_ARM_Half);
+ RelocType = unsigned(MachO::ARM_RELOC_HALF);
Log2Size = 3;
return true;
case ARM::fixup_arm_movw_lo16:
case ARM::fixup_arm_movw_lo16_pcrel:
- RelocType = unsigned(macho::RIT_ARM_Half);
+ RelocType = unsigned(MachO::ARM_RELOC_HALF);
Log2Size = 0;
return true;
case ARM::fixup_t2_movw_lo16:
case ARM::fixup_t2_movw_lo16_pcrel:
- RelocType = unsigned(macho::RIT_ARM_Half);
+ RelocType = unsigned(MachO::ARM_RELOC_HALF);
Log2Size = 2;
return true;
}
uint64_t &FixedValue) {
uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
- unsigned Type = macho::RIT_ARM_Half;
+ unsigned Type = MachO::ARM_RELOC_HALF;
// See <reloc.h>.
const MCSymbol *A = &Target.getSymA()->getSymbol();
"' can not be undefined in a subtraction expression");
// Select the appropriate difference relocation type.
- Type = macho::RIT_ARM_HalfDifference;
+ Type = MachO::ARM_RELOC_HALF_SECTDIFF;
Value2 = Writer->getSymbolAddress(B_SD, Layout);
FixedValue -= Writer->getSectionAddress(B_SD->getFragment()->getParent());
}
break;
}
- if (Type == macho::RIT_ARM_HalfDifference) {
+ if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) {
uint32_t OtherHalf = MovtBit
? (FixedValue & 0xffff) : ((FixedValue & 0xffff0000) >> 16);
- macho::RelocationEntry MRE;
- MRE.Word0 = ((OtherHalf << 0) |
- (macho::RIT_Pair << 24) |
- (MovtBit << 28) |
- (ThumbBit << 29) |
- (IsPCRel << 30) |
- macho::RF_Scattered);
- MRE.Word1 = Value2;
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = ((OtherHalf << 0) |
+ (MachO::ARM_RELOC_PAIR << 24) |
+ (MovtBit << 28) |
+ (ThumbBit << 29) |
+ (IsPCRel << 30) |
+ MachO::R_SCATTERED);
+ MRE.r_word1 = Value2;
Writer->addRelocation(Fragment->getParent(), MRE);
}
- macho::RelocationEntry MRE;
- MRE.Word0 = ((FixupOffset << 0) |
- (Type << 24) |
- (MovtBit << 28) |
- (ThumbBit << 29) |
- (IsPCRel << 30) |
- macho::RF_Scattered);
- MRE.Word1 = Value;
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = ((FixupOffset << 0) |
+ (Type << 24) |
+ (MovtBit << 28) |
+ (ThumbBit << 29) |
+ (IsPCRel << 30) |
+ MachO::R_SCATTERED);
+ MRE.r_word1 = Value;
Writer->addRelocation(Fragment->getParent(), MRE);
}
uint64_t &FixedValue) {
uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
- unsigned Type = macho::RIT_Vanilla;
+ unsigned Type = MachO::ARM_RELOC_VANILLA;
// See <reloc.h>.
const MCSymbol *A = &Target.getSymA()->getSymbol();
"' can not be undefined in a subtraction expression");
// Select the appropriate difference relocation type.
- Type = macho::RIT_Difference;
+ Type = MachO::ARM_RELOC_SECTDIFF;
Value2 = Writer->getSymbolAddress(B_SD, Layout);
FixedValue -= Writer->getSectionAddress(B_SD->getFragment()->getParent());
}
// Relocations are written out in reverse order, so the PAIR comes first.
- if (Type == macho::RIT_Difference ||
- Type == macho::RIT_Generic_LocalDifference) {
- macho::RelocationEntry MRE;
- MRE.Word0 = ((0 << 0) |
- (macho::RIT_Pair << 24) |
- (Log2Size << 28) |
- (IsPCRel << 30) |
- macho::RF_Scattered);
- MRE.Word1 = Value2;
+ if (Type == MachO::ARM_RELOC_SECTDIFF ||
+ Type == MachO::ARM_RELOC_LOCAL_SECTDIFF) {
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = ((0 << 0) |
+ (MachO::ARM_RELOC_PAIR << 24) |
+ (Log2Size << 28) |
+ (IsPCRel << 30) |
+ MachO::R_SCATTERED);
+ MRE.r_word1 = Value2;
Writer->addRelocation(Fragment->getParent(), MRE);
}
- macho::RelocationEntry MRE;
- MRE.Word0 = ((FixupOffset << 0) |
- (Type << 24) |
- (Log2Size << 28) |
- (IsPCRel << 30) |
- macho::RF_Scattered);
- MRE.Word1 = Value;
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = ((FixupOffset << 0) |
+ (Type << 24) |
+ (Log2Size << 28) |
+ (IsPCRel << 30) |
+ MachO::R_SCATTERED);
+ MRE.r_word1 = Value;
Writer->addRelocation(Fragment->getParent(), MRE);
}
switch (RelocType) {
default:
return false;
- case macho::RIT_ARM_Branch24Bit:
+ case MachO::ARM_RELOC_BR24:
// PC pre-adjustment of 8 for these instructions.
Value -= 8;
// ARM BL/BLX has a 25-bit offset.
Range = 0x1ffffff;
break;
- case macho::RIT_ARM_ThumbBranch22Bit:
+ case MachO::ARM_THUMB_RELOC_BR22:
// PC pre-adjustment of 4 for these instructions.
Value -= 4;
// Thumb BL/BLX has a 24-bit offset.
uint64_t &FixedValue) {
unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
unsigned Log2Size;
- unsigned RelocType = macho::RIT_Vanilla;
+ unsigned RelocType = MachO::ARM_RELOC_VANILLA;
if (!getARMFixupKindMachOInfo(Fixup.getKind(), RelocType, Log2Size))
// If we failed to get fixup kind info, it's because there's no legal
// relocation type for the fixup kind. This happens when it's a fixup that's
// scattered relocation entry. Differences always require scattered
// relocations.
if (Target.getSymB()) {
- if (RelocType == macho::RIT_ARM_Half)
+ if (RelocType == MachO::ARM_RELOC_HALF)
return RecordARMScatteredHalfRelocation(Writer, Asm, Layout, Fragment,
Fixup, Target, FixedValue);
return RecordARMScatteredRelocation(Writer, Asm, Layout, Fragment, Fixup,
//
// Is this right for ARM?
uint32_t Offset = Target.getConstant();
- if (IsPCRel && RelocType == macho::RIT_Vanilla)
+ if (IsPCRel && RelocType == MachO::ARM_RELOC_VANILLA)
Offset += 1 << Log2Size;
if (Offset && SD && !Writer->doesSymbolRequireExternRelocation(SD))
return RecordARMScatteredRelocation(Writer, Asm, Layout, Fragment, Fixup,
}
// struct relocation_info (8 bytes)
- macho::RelocationEntry MRE;
- MRE.Word0 = FixupOffset;
- MRE.Word1 = ((Index << 0) |
- (IsPCRel << 24) |
- (Log2Size << 25) |
- (IsExtern << 27) |
- (Type << 28));
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = FixupOffset;
+ MRE.r_word1 = ((Index << 0) |
+ (IsPCRel << 24) |
+ (Log2Size << 25) |
+ (IsExtern << 27) |
+ (Type << 28));
// Even when it's not a scattered relocation, movw/movt always uses
// a PAIR relocation.
- if (Type == macho::RIT_ARM_Half) {
+ if (Type == MachO::ARM_RELOC_HALF) {
// The other-half value only gets populated for the movt and movw
// relocation entries.
uint32_t Value = 0;
Value = FixedValue & 0xffff;
break;
}
- macho::RelocationEntry MREPair;
- MREPair.Word0 = Value;
- MREPair.Word1 = ((0xffffff) |
- (Log2Size << 25) |
- (macho::RIT_Pair << 28));
+ MachO::any_relocation_info MREPair;
+ MREPair.r_word0 = Value;
+ MREPair.r_word1 = ((0xffffff << 0) |
+ (Log2Size << 25) |
+ (MachO::ARM_RELOC_PAIR << 28));
Writer->addRelocation(Fragment->getParent(), MREPair);
}
#include "llvm/MC/MCObjectWriter.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCValue.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/ELF.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MachO.h"
#include "llvm/Support/TargetRegistry.h"
using namespace llvm;
return createPPCMachObjectWriter(
OS,
/*Is64Bit=*/is64,
- (is64 ? object::mach::CTM_PowerPC64 : object::mach::CTM_PowerPC),
- object::mach::CSPPC_ALL);
+ (is64 ? MachO::CPU_TYPE_POWERPC64 : MachO::CPU_TYPE_POWERPC),
+ MachO::CPU_SUBTYPE_POWERPC_ALL);
}
virtual bool doesSectionRequireSymbols(const MCSection &Section) const {
#include "llvm/MC/MCMachObjectWriter.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCValue.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
+#include "llvm/Support/MachO.h"
using namespace llvm;
-using namespace llvm::object;
namespace {
class PPCMachObjectWriter : public MCMachObjectTargetWriter {
Target.isAbsolute() ? MCSymbolRefExpr::VK_None
: Target.getSymA()->getKind();
// determine the type of the relocation
- unsigned Type = macho::RIT_Vanilla;
+ unsigned Type = MachO::GENERIC_RELOC_VANILLA;
if (IsPCRel) { // relative to PC
switch ((unsigned)FixupKind) {
default:
report_fatal_error("Unimplemented fixup kind (relative)");
case PPC::fixup_ppc_br24:
- Type = macho::RIT_PPC_BR24; // R_PPC_REL24
+ Type = MachO::PPC_RELOC_BR24; // R_PPC_REL24
break;
case PPC::fixup_ppc_brcond14:
- Type = macho::RIT_PPC_BR14;
+ Type = MachO::PPC_RELOC_BR14;
break;
case PPC::fixup_ppc_half16:
switch (Modifier) {
default:
llvm_unreachable("Unsupported modifier for half16 fixup");
case MCSymbolRefExpr::VK_PPC_HA:
- Type = macho::RIT_PPC_HA16;
+ Type = MachO::PPC_RELOC_HA16;
break;
case MCSymbolRefExpr::VK_PPC_LO:
- Type = macho::RIT_PPC_LO16;
+ Type = MachO::PPC_RELOC_LO16;
break;
case MCSymbolRefExpr::VK_PPC_HI:
- Type = macho::RIT_PPC_HI16;
+ Type = MachO::PPC_RELOC_HI16;
break;
}
break;
default:
llvm_unreachable("Unsupported modifier for half16 fixup");
case MCSymbolRefExpr::VK_PPC_HA:
- Type = macho::RIT_PPC_HA16_SECTDIFF;
+ Type = MachO::PPC_RELOC_HA16_SECTDIFF;
break;
case MCSymbolRefExpr::VK_PPC_LO:
- Type = macho::RIT_PPC_LO16_SECTDIFF;
+ Type = MachO::PPC_RELOC_LO16_SECTDIFF;
break;
case MCSymbolRefExpr::VK_PPC_HI:
- Type = macho::RIT_PPC_HI16_SECTDIFF;
+ Type = MachO::PPC_RELOC_HI16_SECTDIFF;
break;
}
break;
return Type;
}
-static void makeRelocationInfo(macho::RelocationEntry &MRE,
+static void makeRelocationInfo(MachO::any_relocation_info &MRE,
const uint32_t FixupOffset, const uint32_t Index,
const unsigned IsPCRel, const unsigned Log2Size,
const unsigned IsExtern, const unsigned Type) {
- MRE.Word0 = FixupOffset;
+ MRE.r_word0 = FixupOffset;
// The bitfield offsets that work (as determined by trial-and-error)
// are different than what is documented in the mach-o manuals.
- // Is this an endianness issue w/ PPC?
- MRE.Word1 = ((Index << 8) | // was << 0
- (IsPCRel << 7) | // was << 24
- (Log2Size << 5) | // was << 25
- (IsExtern << 4) | // was << 27
- (Type << 0)); // was << 28
+ // This appears to be an endianness issue; reversing the order of the
+ // documented bitfields in <llvm/Support/MachO.h> fixes this (but
+ // breaks x86/ARM assembly).
+ MRE.r_word1 = ((Index << 8) | // was << 0
+ (IsPCRel << 7) | // was << 24
+ (Log2Size << 5) | // was << 25
+ (IsExtern << 4) | // was << 27
+ (Type << 0)); // was << 28
}
static void
-makeScatteredRelocationInfo(macho::RelocationEntry &MRE, const uint32_t Addr,
- const unsigned Type, const unsigned Log2Size,
- const unsigned IsPCRel, const uint32_t Value2) {
+makeScatteredRelocationInfo(MachO::any_relocation_info &MRE,
+ const uint32_t Addr, const unsigned Type,
+ const unsigned Log2Size, const unsigned IsPCRel,
+ const uint32_t Value2) {
// For notes on bitfield positions and endianness, see:
// https://developer.apple.com/library/mac/documentation/developertools/conceptual/MachORuntime/Reference/reference.html#//apple_ref/doc/uid/20001298-scattered_relocation_entry
- MRE.Word0 = ((Addr << 0) | (Type << 24) | (Log2Size << 28) | (IsPCRel << 30) |
- macho::RF_Scattered);
- MRE.Word1 = Value2;
+ MRE.r_word0 = ((Addr << 0) | (Type << 24) | (Log2Size << 28) |
+ (IsPCRel << 30) | MachO::R_SCATTERED);
+ MRE.r_word1 = Value2;
}
/// Compute fixup offset (address).
report_fatal_error("symbol '" + B->getSymbol().getName() +
"' can not be undefined in a subtraction expression");
- // FIXME: is Type correct? see include/llvm/Object/MachOFormat.h
+ // FIXME: is Type correct? see include/llvm/Support/MachO.h
Value2 = Writer->getSymbolAddress(B_SD, Layout);
FixedValue -= Writer->getSectionAddress(B_SD->getFragment()->getParent());
}
// FIXME: does FixedValue get used??
// Relocations are written out in reverse order, so the PAIR comes first.
- if (Type == macho::RIT_PPC_SECTDIFF || Type == macho::RIT_PPC_HI16_SECTDIFF ||
- Type == macho::RIT_PPC_LO16_SECTDIFF ||
- Type == macho::RIT_PPC_HA16_SECTDIFF ||
- Type == macho::RIT_PPC_LO14_SECTDIFF ||
- Type == macho::RIT_PPC_LOCAL_SECTDIFF) {
+ if (Type == MachO::PPC_RELOC_SECTDIFF ||
+ Type == MachO::PPC_RELOC_HI16_SECTDIFF ||
+ Type == MachO::PPC_RELOC_LO16_SECTDIFF ||
+ Type == MachO::PPC_RELOC_HA16_SECTDIFF ||
+ Type == MachO::PPC_RELOC_LO14_SECTDIFF ||
+ Type == MachO::PPC_RELOC_LOCAL_SECTDIFF) {
// X86 had this piece, but ARM does not
// If the offset is too large to fit in a scattered relocation,
// we're hosed. It's an unfortunate limitation of the MachO format.
// see PPCMCExpr::EvaluateAsRelocatableImpl()
uint32_t other_half = 0;
switch (Type) {
- case macho::RIT_PPC_LO16_SECTDIFF:
+ case MachO::PPC_RELOC_LO16_SECTDIFF:
other_half = (FixedValue >> 16) & 0xffff;
// applyFixupOffset longer extracts the high part because it now assumes
// this was already done.
// So we need to adjust FixedValue again here.
FixedValue &= 0xffff;
break;
- case macho::RIT_PPC_HA16_SECTDIFF:
+ case MachO::PPC_RELOC_HA16_SECTDIFF:
other_half = FixedValue & 0xffff;
FixedValue =
((FixedValue >> 16) + ((FixedValue & 0x8000) ? 1 : 0)) & 0xffff;
break;
- case macho::RIT_PPC_HI16_SECTDIFF:
+ case MachO::PPC_RELOC_HI16_SECTDIFF:
other_half = FixedValue & 0xffff;
FixedValue = (FixedValue >> 16) & 0xffff;
break;
break;
}
- macho::RelocationEntry MRE;
- makeScatteredRelocationInfo(MRE, other_half, macho::RIT_Pair, Log2Size,
- IsPCRel, Value2);
+ MachO::any_relocation_info MRE;
+ makeScatteredRelocationInfo(MRE, other_half, MachO::GENERIC_RELOC_PAIR,
+ Log2Size, IsPCRel, Value2);
Writer->addRelocation(Fragment->getParent(), MRE);
} else {
// If the offset is more than 24-bits, it won't fit in a scattered
if (FixupOffset > 0xffffff)
return false;
}
- macho::RelocationEntry MRE;
+ MachO::any_relocation_info MRE;
makeScatteredRelocationInfo(MRE, FixupOffset, Type, Log2Size, IsPCRel, Value);
Writer->addRelocation(Fragment->getParent(), MRE);
return true;
// relocations.
if (Target.getSymB() &&
// Q: are branch targets ever scattered?
- RelocType != macho::RIT_PPC_BR24 && RelocType != macho::RIT_PPC_BR14) {
+ RelocType != MachO::PPC_RELOC_BR24 &&
+ RelocType != MachO::PPC_RELOC_BR14) {
RecordScatteredRelocation(Writer, Asm, Layout, Fragment, Fixup, Target,
Log2Size, FixedValue);
return;
}
// struct relocation_info (8 bytes)
- macho::RelocationEntry MRE;
+ MachO::any_relocation_info MRE;
makeRelocationInfo(MRE, FixupOffset, Index, IsPCRel, Log2Size, IsExtern,
Type);
Writer->addRelocation(Fragment->getParent(), MRE);
#include "llvm/MC/MCSectionCOFF.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSectionMachO.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ELF.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MachO.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createX86MachObjectWriter(OS, /*Is64Bit=*/false,
- object::mach::CTM_i386,
- object::mach::CSX86_ALL);
+ MachO::CPU_TYPE_I386,
+ MachO::CPU_SUBTYPE_I386_ALL);
}
};
MCObjectWriter *createObjectWriter(raw_ostream &OS) const {
return createX86MachObjectWriter(OS, /*Is64Bit=*/true,
- object::mach::CTM_x86_64,
- object::mach::CSX86_ALL);
+ MachO::CPU_TYPE_X86_64,
+ MachO::CPU_SUBTYPE_X86_64_ALL);
}
virtual bool doesSectionRequireSymbols(const MCSection &Section) const {
using namespace llvm;
using namespace object;
-using namespace macho;
+using namespace MachO;
namespace {
class X86_64MachORelocationInfo : public MCRelocationInfo {
StringRef SymName; SymI->getName(SymName);
uint64_t SymAddr; SymI->getAddress(SymAddr);
- RelocationEntry RE = Obj->getRelocation(Rel.getRawDataRefImpl());
+ any_relocation_info RE = Obj->getRelocation(Rel.getRawDataRefImpl());
bool isPCRel = Obj->getAnyRelocationPCRel(RE);
MCSymbol *Sym = Ctx.GetOrCreateSymbol(SymName);
const MCExpr *Expr = 0;
switch(RelType) {
- case RIT_X86_64_TLV:
+ case X86_64_RELOC_TLV:
Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_TLVP, Ctx);
break;
- case RIT_X86_64_Signed4:
+ case X86_64_RELOC_SIGNED_4:
Expr = MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Sym, Ctx),
MCConstantExpr::Create(4, Ctx),
Ctx);
break;
- case RIT_X86_64_Signed2:
+ case X86_64_RELOC_SIGNED_2:
Expr = MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Sym, Ctx),
MCConstantExpr::Create(2, Ctx),
Ctx);
break;
- case RIT_X86_64_Signed1:
+ case X86_64_RELOC_SIGNED_1:
Expr = MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Sym, Ctx),
MCConstantExpr::Create(1, Ctx),
Ctx);
break;
- case RIT_X86_64_GOTLoad:
+ case X86_64_RELOC_GOT_LOAD:
Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTPCREL, Ctx);
break;
- case RIT_X86_64_GOT:
+ case X86_64_RELOC_GOT:
Expr = MCSymbolRefExpr::Create(Sym, isPCRel ?
MCSymbolRefExpr::VK_GOTPCREL :
MCSymbolRefExpr::VK_GOT,
Ctx);
break;
- case RIT_X86_64_Subtractor:
+ case X86_64_RELOC_SUBTRACTOR:
{
RelocationRef RelNext;
Obj->getRelocationNext(Rel.getRawDataRefImpl(), RelNext);
- RelocationEntry RENext = Obj->getRelocation(RelNext.getRawDataRefImpl());
+ any_relocation_info RENext = Obj->getRelocation(RelNext.getRawDataRefImpl());
// X86_64_SUBTRACTOR must be followed by a relocation of type
- // X86_64_RELOC_UNSIGNED .
+ // X86_64_RELOC_UNSIGNED.
// NOTE: Scattered relocations don't exist on x86_64.
unsigned RType = Obj->getAnyRelocationType(RENext);
- if (RType != RIT_X86_64_Unsigned)
+ if (RType != X86_64_RELOC_UNSIGNED)
report_fatal_error("Expected X86_64_RELOC_UNSIGNED after "
"X86_64_RELOC_SUBTRACTOR.");
#include "llvm/MC/MCMachObjectWriter.h"
#include "llvm/MC/MCSectionMachO.h"
#include "llvm/MC/MCValue.h"
-#include "llvm/Object/MachOFormat.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Format.h"
+#include "llvm/Support/MachO.h"
using namespace llvm;
-using namespace llvm::object;
namespace {
class X86MachObjectWriter : public MCMachObjectTargetWriter {
if (Target.isAbsolute()) { // constant
// SymbolNum of 0 indicates the absolute section.
- Type = macho::RIT_X86_64_Unsigned;
+ Type = MachO::X86_64_RELOC_UNSIGNED;
Index = 0;
// FIXME: I believe this is broken, I don't think the linker can understand
// is to use an absolute symbol (which we don't support yet).
if (IsPCRel) {
IsExtern = 1;
- Type = macho::RIT_X86_64_Branch;
+ Type = MachO::X86_64_RELOC_BRANCH;
}
} else if (Target.getSymB()) { // A - B + constant
const MCSymbol *A = &Target.getSymA()->getSymbol();
Index = A_SD.getFragment()->getParent()->getOrdinal() + 1;
IsExtern = 0;
}
- Type = macho::RIT_X86_64_Unsigned;
-
- macho::RelocationEntry MRE;
- MRE.Word0 = FixupOffset;
- MRE.Word1 = ((Index << 0) |
- (IsPCRel << 24) |
- (Log2Size << 25) |
- (IsExtern << 27) |
- (Type << 28));
+ Type = MachO::X86_64_RELOC_UNSIGNED;
+
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = FixupOffset;
+ MRE.r_word1 = ((Index << 0) |
+ (IsPCRel << 24) |
+ (Log2Size << 25) |
+ (IsExtern << 27) |
+ (Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
if (B_Base) {
Index = B_SD.getFragment()->getParent()->getOrdinal() + 1;
IsExtern = 0;
}
- Type = macho::RIT_X86_64_Subtractor;
+ Type = MachO::X86_64_RELOC_SUBTRACTOR;
} else {
const MCSymbol *Symbol = &Target.getSymA()->getSymbol();
MCSymbolData &SD = Asm.getSymbolData(*Symbol);
// rewrite the movq to an leaq at link time if the symbol ends up in
// the same linkage unit.
if (unsigned(Fixup.getKind()) == X86::reloc_riprel_4byte_movq_load)
- Type = macho::RIT_X86_64_GOTLoad;
+ Type = MachO::X86_64_RELOC_GOT_LOAD;
else
- Type = macho::RIT_X86_64_GOT;
+ Type = MachO::X86_64_RELOC_GOT;
} else if (Modifier == MCSymbolRefExpr::VK_TLVP) {
- Type = macho::RIT_X86_64_TLV;
+ Type = MachO::X86_64_RELOC_TLV;
} else if (Modifier != MCSymbolRefExpr::VK_None) {
report_fatal_error("unsupported symbol modifier in relocation");
} else {
- Type = macho::RIT_X86_64_Signed;
+ Type = MachO::X86_64_RELOC_SIGNED;
// The Darwin x86_64 relocation format has a problem where it cannot
// encode an address (L<foo> + <constant>) which is outside the atom
// (the additional bias), but instead appear to just look at the final
// offset.
switch (-(Target.getConstant() + (1LL << Log2Size))) {
- case 1: Type = macho::RIT_X86_64_Signed1; break;
- case 2: Type = macho::RIT_X86_64_Signed2; break;
- case 4: Type = macho::RIT_X86_64_Signed4; break;
+ case 1: Type = MachO::X86_64_RELOC_SIGNED_1; break;
+ case 2: Type = MachO::X86_64_RELOC_SIGNED_2; break;
+ case 4: Type = MachO::X86_64_RELOC_SIGNED_4; break;
}
}
} else {
report_fatal_error("unsupported symbol modifier in branch "
"relocation");
- Type = macho::RIT_X86_64_Branch;
+ Type = MachO::X86_64_RELOC_BRANCH;
}
} else {
if (Modifier == MCSymbolRefExpr::VK_GOT) {
- Type = macho::RIT_X86_64_GOT;
+ Type = MachO::X86_64_RELOC_GOT;
} else if (Modifier == MCSymbolRefExpr::VK_GOTPCREL) {
// GOTPCREL is allowed as a modifier on non-PCrel instructions, in which
// case all we do is set the PCrel bit in the relocation entry; this is
// used with exception handling, for example. The source is required to
// include any necessary offset directly.
- Type = macho::RIT_X86_64_GOT;
+ Type = MachO::X86_64_RELOC_GOT;
IsPCRel = 1;
} else if (Modifier == MCSymbolRefExpr::VK_TLVP) {
report_fatal_error("TLVP symbol modifier should have been rip-rel");
} else if (Modifier != MCSymbolRefExpr::VK_None)
report_fatal_error("unsupported symbol modifier in relocation");
else {
- Type = macho::RIT_X86_64_Unsigned;
+ Type = MachO::X86_64_RELOC_UNSIGNED;
unsigned Kind = Fixup.getKind();
if (Kind == X86::reloc_signed_4byte)
report_fatal_error("32-bit absolute addressing is not supported in "
FixedValue = Value;
// struct relocation_info (8 bytes)
- macho::RelocationEntry MRE;
- MRE.Word0 = FixupOffset;
- MRE.Word1 = ((Index << 0) |
- (IsPCRel << 24) |
- (Log2Size << 25) |
- (IsExtern << 27) |
- (Type << 28));
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = FixupOffset;
+ MRE.r_word1 = ((Index << 0) |
+ (IsPCRel << 24) |
+ (Log2Size << 25) |
+ (IsExtern << 27) |
+ (Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
}
uint64_t &FixedValue) {
uint32_t FixupOffset = Layout.getFragmentOffset(Fragment)+Fixup.getOffset();
unsigned IsPCRel = Writer->isFixupKindPCRel(Asm, Fixup.getKind());
- unsigned Type = macho::RIT_Vanilla;
+ unsigned Type = MachO::GENERIC_RELOC_VANILLA;
// See <reloc.h>.
const MCSymbol *A = &Target.getSymA()->getSymbol();
// Note that there is no longer any semantic difference between these two
// relocation types from the linkers point of view, this is done solely for
// pedantic compatibility with 'as'.
- Type = A_SD->isExternal() ? (unsigned)macho::RIT_Difference :
- (unsigned)macho::RIT_Generic_LocalDifference;
+ Type = A_SD->isExternal() ? (unsigned)MachO::GENERIC_RELOC_SECTDIFF :
+ (unsigned)MachO::GENERIC_RELOC_LOCAL_SECTDIFF;
Value2 = Writer->getSymbolAddress(B_SD, Layout);
FixedValue -= Writer->getSectionAddress(B_SD->getFragment()->getParent());
}
// Relocations are written out in reverse order, so the PAIR comes first.
- if (Type == macho::RIT_Difference ||
- Type == macho::RIT_Generic_LocalDifference) {
+ if (Type == MachO::GENERIC_RELOC_SECTDIFF ||
+ Type == MachO::GENERIC_RELOC_LOCAL_SECTDIFF) {
// If the offset is too large to fit in a scattered relocation,
// we're hosed. It's an unfortunate limitation of the MachO format.
if (FixupOffset > 0xffffff) {
llvm_unreachable("fatal error returned?!");
}
- macho::RelocationEntry MRE;
- MRE.Word0 = ((0 << 0) |
- (macho::RIT_Pair << 24) |
- (Log2Size << 28) |
- (IsPCRel << 30) |
- macho::RF_Scattered);
- MRE.Word1 = Value2;
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = ((0 << 0) | // r_address
+ (MachO::GENERIC_RELOC_PAIR << 24) | // r_type
+ (Log2Size << 28) |
+ (IsPCRel << 30) |
+ MachO::R_SCATTERED);
+ MRE.r_word1 = Value2;
Writer->addRelocation(Fragment->getParent(), MRE);
} else {
// If the offset is more than 24-bits, it won't fit in a scattered
return false;
}
- macho::RelocationEntry MRE;
- MRE.Word0 = ((FixupOffset << 0) |
- (Type << 24) |
- (Log2Size << 28) |
- (IsPCRel << 30) |
- macho::RF_Scattered);
- MRE.Word1 = Value;
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = ((FixupOffset << 0) |
+ (Type << 24) |
+ (Log2Size << 28) |
+ (IsPCRel << 30) |
+ MachO::R_SCATTERED);
+ MRE.r_word1 = Value;
Writer->addRelocation(Fragment->getParent(), MRE);
return true;
}
}
// struct relocation_info (8 bytes)
- macho::RelocationEntry MRE;
- MRE.Word0 = Value;
- MRE.Word1 = ((Index << 0) |
- (IsPCRel << 24) |
- (Log2Size << 25) |
- (1 << 27) | // Extern
- (macho::RIT_Generic_TLV << 28)); // Type
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = Value;
+ MRE.r_word1 = ((Index << 0) |
+ (IsPCRel << 24) |
+ (Log2Size << 25) |
+ (1 << 27) | // r_extern
+ (MachO::GENERIC_RELOC_TLV << 28)); // r_type
Writer->addRelocation(Fragment->getParent(), MRE);
}
//
// FIXME: Currently, these are never generated (see code below). I cannot
// find a case where they are actually emitted.
- Type = macho::RIT_Vanilla;
+ Type = MachO::GENERIC_RELOC_VANILLA;
} else {
// Resolve constant variables.
if (SD->getSymbol().isVariable()) {
if (IsPCRel)
FixedValue -= Writer->getSectionAddress(Fragment->getParent());
- Type = macho::RIT_Vanilla;
+ Type = MachO::GENERIC_RELOC_VANILLA;
}
// struct relocation_info (8 bytes)
- macho::RelocationEntry MRE;
- MRE.Word0 = FixupOffset;
- MRE.Word1 = ((Index << 0) |
- (IsPCRel << 24) |
- (Log2Size << 25) |
- (IsExtern << 27) |
- (Type << 28));
+ MachO::any_relocation_info MRE;
+ MRE.r_word0 = FixupOffset;
+ MRE.r_word1 = ((Index << 0) |
+ (IsPCRel << 24) |
+ (Log2Size << 25) |
+ (IsExtern << 27) |
+ (Type << 28));
Writer->addRelocation(Fragment->getParent(), MRE);
}
uint64_t Value;
switch (Kind) {
- case macho::Data:
+ case MachO::DICE_KIND_DATA:
switch (Size) {
case 4:
Value = bytes[3] << 24 |
}
outs() << "\t@ KIND_DATA\n";
break;
- case macho::JumpTable8:
+ case MachO::DICE_KIND_JUMP_TABLE8:
Value = bytes[0];
outs() << "\t.byte " << Value << "\t@ KIND_JUMP_TABLE8";
break;
- case macho::JumpTable16:
+ case MachO::DICE_KIND_JUMP_TABLE16:
Value = bytes[1] << 8 |
bytes[0];
outs() << "\t.short " << Value << "\t@ KIND_JUMP_TABLE16";
break;
- case macho::JumpTable32:
+ case MachO::DICE_KIND_JUMP_TABLE32:
Value = bytes[3] << 24 |
bytes[2] << 16 |
bytes[1] << 8 |
}
static void
-getSectionsAndSymbols(const macho::Header Header,
+getSectionsAndSymbols(const MachO::mach_header Header,
MachOObjectFile *MachOObj,
std::vector<SectionRef> &Sections,
std::vector<SymbolRef> &Symbols,
MachOObj->getFirstLoadCommandInfo();
bool BaseSegmentAddressSet = false;
for (unsigned i = 0; ; ++i) {
- if (Command.C.Type == macho::LCT_FunctionStarts) {
+ if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
// We found a function starts segment, parse the addresses for later
// consumption.
- macho::LinkeditDataLoadCommand LLC =
+ MachO::linkedit_data_command LLC =
MachOObj->getLinkeditDataLoadCommand(Command);
- MachOObj->ReadULEB128s(LLC.DataOffset, FoundFns);
+ MachOObj->ReadULEB128s(LLC.dataoff, FoundFns);
}
- else if (Command.C.Type == macho::LCT_Segment) {
- macho::SegmentLoadCommand SLC =
+ else if (Command.C.cmd == MachO::LC_SEGMENT) {
+ MachO::segment_command SLC =
MachOObj->getSegmentLoadCommand(Command);
- StringRef SegName = SLC.Name;
+ StringRef SegName = SLC.segname;
if(!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
BaseSegmentAddressSet = true;
- BaseSegmentAddress = SLC.VMAddress;
+ BaseSegmentAddress = SLC.vmaddr;
}
}
- if (i == Header.NumLoadCommands - 1)
+ if (i == Header.ncmds - 1)
break;
else
Command = MachOObj->getNextLoadCommandInfo(Command);
outs() << '\n' << Filename << ":\n\n";
- macho::Header Header = MachOOF->getHeader();
+ MachO::mach_header Header = MachOOF->getHeader();
// FIXME: FoundFns isn't used anymore. Using symbols/LC_FUNCTION_STARTS to
// determine function locations will eventually go in MCObjectDisassembler.
// Build a data in code table that is sorted on by the address of each entry.
uint64_t BaseAddress = 0;
- if (Header.FileType == macho::HFT_Object)
+ if (Header.filetype == MachO::MH_OBJECT)
Sections[0].getAddress(BaseAddress);
else
BaseAddress = BaseSegmentAddress;
DataRefImpl Sec,
MachOSection &Section) {
if (!Obj->is64Bit()) {
- macho::Section Sect = Obj->getSection(Sec);
- Section.Address = Sect.Address;
- Section.Size = Sect.Size;
- Section.Offset = Sect.Offset;
- Section.Alignment = Sect.Align;
- Section.RelocationTableOffset = Sect.RelocationTableOffset;
- Section.NumRelocationTableEntries = Sect.NumRelocationTableEntries;
- Section.Flags = Sect.Flags;
- Section.Reserved1 = Sect.Reserved1;
- Section.Reserved2 = Sect.Reserved2;
+ MachO::section Sect = Obj->getSection(Sec);
+ Section.Address = Sect.addr;
+ Section.Size = Sect.size;
+ Section.Offset = Sect.offset;
+ Section.Alignment = Sect.align;
+ Section.RelocationTableOffset = Sect.reloff;
+ Section.NumRelocationTableEntries = Sect.nreloc;
+ Section.Flags = Sect.flags;
+ Section.Reserved1 = Sect.reserved1;
+ Section.Reserved2 = Sect.reserved2;
return;
}
- macho::Section64 Sect = Obj->getSection64(Sec);
- Section.Address = Sect.Address;
- Section.Size = Sect.Size;
- Section.Offset = Sect.Offset;
- Section.Alignment = Sect.Align;
- Section.RelocationTableOffset = Sect.RelocationTableOffset;
- Section.NumRelocationTableEntries = Sect.NumRelocationTableEntries;
- Section.Flags = Sect.Flags;
- Section.Reserved1 = Sect.Reserved1;
- Section.Reserved2 = Sect.Reserved2;
+ MachO::section_64 Sect = Obj->getSection64(Sec);
+ Section.Address = Sect.addr;
+ Section.Size = Sect.size;
+ Section.Offset = Sect.offset;
+ Section.Alignment = Sect.align;
+ Section.RelocationTableOffset = Sect.reloff;
+ Section.NumRelocationTableEntries = Sect.nreloc;
+ Section.Flags = Sect.flags;
+ Section.Reserved1 = Sect.reserved1;
+ Section.Reserved2 = Sect.reserved2;
}
DataRefImpl DRI,
MachOSymbol &Symbol) {
if (!Obj->is64Bit()) {
- macho::SymbolTableEntry Entry = Obj->getSymbolTableEntry(DRI);
- Symbol.StringIndex = Entry.StringIndex;
- Symbol.Type = Entry.Type;
- Symbol.SectionIndex = Entry.SectionIndex;
- Symbol.Flags = Entry.Flags;
- Symbol.Value = Entry.Value;
+ MachO::nlist Entry = Obj->getSymbolTableEntry(DRI);
+ Symbol.StringIndex = Entry.n_strx;
+ Symbol.Type = Entry.n_type;
+ Symbol.SectionIndex = Entry.n_sect;
+ Symbol.Flags = Entry.n_desc;
+ Symbol.Value = Entry.n_value;
return;
}
- macho::Symbol64TableEntry Entry = Obj->getSymbol64TableEntry(DRI);
- Symbol.StringIndex = Entry.StringIndex;
- Symbol.Type = Entry.Type;
- Symbol.SectionIndex = Entry.SectionIndex;
- Symbol.Flags = Entry.Flags;
- Symbol.Value = Entry.Value;
+ MachO::nlist_64 Entry = Obj->getSymbol64TableEntry(DRI);
+ Symbol.StringIndex = Entry.n_strx;
+ Symbol.Type = Entry.n_type;
+ Symbol.SectionIndex = Entry.n_sect;
+ Symbol.Flags = Entry.n_desc;
+ Symbol.Value = Entry.n_value;
}
void MachODumper::printFileHeaders() {
return;
DataRefImpl DR = RelI->getRawDataRefImpl();
- macho::RelocationEntry RE = Obj->getRelocation(DR);
+ MachO::any_relocation_info RE = Obj->getRelocation(DR);
bool IsScattered = Obj->isRelocationScattered(RE);
if (opts::ExpandRelocs) {
error_code EC;
for (relocation_iterator I = Obj.getSectionRelBegin(Index),
E = Obj.getSectionRelEnd(Index); I != E; I.increment(EC), ++RelNum) {
- macho::RelocationEntry RE = Obj.getRelocation(I->getRawDataRefImpl());
+ MachO::any_relocation_info RE = Obj.getRelocation(I->getRawDataRefImpl());
outs() << " # Relocation " << RelNum << "\n";
- outs() << " (('word-0', " << format("0x%x", RE.Word0) << "),\n";
- outs() << " ('word-1', " << format("0x%x", RE.Word1) << ")),\n";
+ outs() << " (('word-0', " << format("0x%x", RE.r_word0) << "),\n";
+ outs() << " ('word-1', " << format("0x%x", RE.r_word1) << ")),\n";
}
outs() << " ])\n";
static int DumpSegmentCommand(const MachOObjectFile &Obj,
const MachOObjectFile::LoadCommandInfo &LCI) {
- macho::SegmentLoadCommand SLC = Obj.getSegmentLoadCommand(LCI);
+ MachO::segment_command SLC = Obj.getSegmentLoadCommand(LCI);
- DumpSegmentCommandData(StringRef(SLC.Name, 16), SLC.VMAddress,
- SLC.VMSize, SLC.FileOffset, SLC.FileSize,
- SLC.MaxVMProtection, SLC.InitialVMProtection,
- SLC.NumSections, SLC.Flags);
+ DumpSegmentCommandData(StringRef(SLC.segname, 16), SLC.vmaddr,
+ SLC.vmsize, SLC.fileoff, SLC.filesize,
+ SLC.maxprot, SLC.initprot, SLC.nsects, SLC.flags);
// Dump the sections.
outs() << " ('sections', [\n";
- for (unsigned i = 0; i != SLC.NumSections; ++i) {
- macho::Section Sect = Obj.getSection(LCI, i);
- DumpSectionData(Obj, i, StringRef(Sect.Name, 16),
- StringRef(Sect.SegmentName, 16), Sect.Address,
- Sect.Size, Sect.Offset, Sect.Align,
- Sect.RelocationTableOffset,
- Sect.NumRelocationTableEntries, Sect.Flags,
- Sect.Reserved1, Sect.Reserved2);
+ for (unsigned i = 0; i != SLC.nsects; ++i) {
+ MachO::section Sect = Obj.getSection(LCI, i);
+ DumpSectionData(Obj, i, StringRef(Sect.sectname, 16),
+ StringRef(Sect.segname, 16), Sect.addr,
+ Sect.size, Sect.offset, Sect.align,
+ Sect.reloff, Sect.nreloc, Sect.flags,
+ Sect.reserved1, Sect.reserved2);
}
outs() << " ])\n";
static int DumpSegment64Command(const MachOObjectFile &Obj,
const MachOObjectFile::LoadCommandInfo &LCI) {
- macho::Segment64LoadCommand SLC = Obj.getSegment64LoadCommand(LCI);
- DumpSegmentCommandData(StringRef(SLC.Name, 16), SLC.VMAddress,
- SLC.VMSize, SLC.FileOffset, SLC.FileSize,
- SLC.MaxVMProtection, SLC.InitialVMProtection,
- SLC.NumSections, SLC.Flags);
+ MachO::segment_command_64 SLC = Obj.getSegment64LoadCommand(LCI);
+ DumpSegmentCommandData(StringRef(SLC.segname, 16), SLC.vmaddr,
+ SLC.vmsize, SLC.fileoff, SLC.filesize,
+ SLC.maxprot, SLC.initprot, SLC.nsects, SLC.flags);
// Dump the sections.
outs() << " ('sections', [\n";
- for (unsigned i = 0; i != SLC.NumSections; ++i) {
- macho::Section64 Sect = Obj.getSection64(LCI, i);
-
- DumpSectionData(Obj, i, StringRef(Sect.Name, 16),
- StringRef(Sect.SegmentName, 16), Sect.Address,
- Sect.Size, Sect.Offset, Sect.Align,
- Sect.RelocationTableOffset,
- Sect.NumRelocationTableEntries, Sect.Flags,
- Sect.Reserved1, Sect.Reserved2,
- Sect.Reserved3);
+ for (unsigned i = 0; i != SLC.nsects; ++i) {
+ MachO::section_64 Sect = Obj.getSection64(LCI, i);
+
+ DumpSectionData(Obj, i, StringRef(Sect.sectname, 16),
+ StringRef(Sect.segname, 16), Sect.addr,
+ Sect.size, Sect.offset, Sect.align,
+ Sect.reloff, Sect.nreloc, Sect.flags,
+ Sect.reserved1, Sect.reserved2,
+ Sect.reserved3);
}
outs() << " ])\n";
}
static int DumpSymtabCommand(const MachOObjectFile &Obj) {
- macho::SymtabLoadCommand SLC = Obj.getSymtabLoadCommand();
+ MachO::symtab_command SLC = Obj.getSymtabLoadCommand();
- outs() << " ('symoff', " << SLC.SymbolTableOffset << ")\n";
- outs() << " ('nsyms', " << SLC.NumSymbolTableEntries << ")\n";
- outs() << " ('stroff', " << SLC.StringTableOffset << ")\n";
- outs() << " ('strsize', " << SLC.StringTableSize << ")\n";
+ outs() << " ('symoff', " << SLC.symoff << ")\n";
+ outs() << " ('nsyms', " << SLC.nsyms << ")\n";
+ outs() << " ('stroff', " << SLC.stroff << ")\n";
+ outs() << " ('strsize', " << SLC.strsize << ")\n";
// Dump the string data.
outs() << " ('_string_data', '";
I.increment(EC), ++SymNum) {
DataRefImpl DRI = I->getRawDataRefImpl();
if (Obj.is64Bit()) {
- macho::Symbol64TableEntry STE = Obj.getSymbol64TableEntry(DRI);
- DumpSymbolTableEntryData(Obj, SymNum, STE.StringIndex, STE.Type,
- STE.SectionIndex, STE.Flags, STE.Value,
+ MachO::nlist_64 STE = Obj.getSymbol64TableEntry(DRI);
+ DumpSymbolTableEntryData(Obj, SymNum, STE.n_strx, STE.n_type,
+ STE.n_sect, STE.n_desc, STE.n_value,
StringTable);
} else {
- macho::SymbolTableEntry STE = Obj.getSymbolTableEntry(DRI);
- DumpSymbolTableEntryData(Obj, SymNum, STE.StringIndex, STE.Type,
- STE.SectionIndex, STE.Flags, STE.Value,
+ MachO::nlist STE = Obj.getSymbolTableEntry(DRI);
+ DumpSymbolTableEntryData(Obj, SymNum, STE.n_strx, STE.n_type,
+ STE.n_sect, STE.n_desc, STE.n_value,
StringTable);
}
}
}
static int DumpDysymtabCommand(const MachOObjectFile &Obj) {
- macho::DysymtabLoadCommand DLC = Obj.getDysymtabLoadCommand();
-
- outs() << " ('ilocalsym', " << DLC.LocalSymbolsIndex << ")\n";
- outs() << " ('nlocalsym', " << DLC.NumLocalSymbols << ")\n";
- outs() << " ('iextdefsym', " << DLC.ExternalSymbolsIndex << ")\n";
- outs() << " ('nextdefsym', " << DLC.NumExternalSymbols << ")\n";
- outs() << " ('iundefsym', " << DLC.UndefinedSymbolsIndex << ")\n";
- outs() << " ('nundefsym', " << DLC.NumUndefinedSymbols << ")\n";
- outs() << " ('tocoff', " << DLC.TOCOffset << ")\n";
- outs() << " ('ntoc', " << DLC.NumTOCEntries << ")\n";
- outs() << " ('modtaboff', " << DLC.ModuleTableOffset << ")\n";
- outs() << " ('nmodtab', " << DLC.NumModuleTableEntries << ")\n";
- outs() << " ('extrefsymoff', " << DLC.ReferenceSymbolTableOffset << ")\n";
- outs() << " ('nextrefsyms', "
- << DLC.NumReferencedSymbolTableEntries << ")\n";
- outs() << " ('indirectsymoff', " << DLC.IndirectSymbolTableOffset << ")\n";
- outs() << " ('nindirectsyms', "
- << DLC.NumIndirectSymbolTableEntries << ")\n";
- outs() << " ('extreloff', " << DLC.ExternalRelocationTableOffset << ")\n";
- outs() << " ('nextrel', " << DLC.NumExternalRelocationTableEntries << ")\n";
- outs() << " ('locreloff', " << DLC.LocalRelocationTableOffset << ")\n";
- outs() << " ('nlocrel', " << DLC.NumLocalRelocationTableEntries << ")\n";
+ MachO::dysymtab_command DLC = Obj.getDysymtabLoadCommand();
+
+ outs() << " ('ilocalsym', " << DLC.ilocalsym << ")\n";
+ outs() << " ('nlocalsym', " << DLC.nlocalsym << ")\n";
+ outs() << " ('iextdefsym', " << DLC.iextdefsym << ")\n";
+ outs() << " ('nextdefsym', " << DLC.nextdefsym << ")\n";
+ outs() << " ('iundefsym', " << DLC.iundefsym << ")\n";
+ outs() << " ('nundefsym', " << DLC.nundefsym << ")\n";
+ outs() << " ('tocoff', " << DLC.tocoff << ")\n";
+ outs() << " ('ntoc', " << DLC.ntoc << ")\n";
+ outs() << " ('modtaboff', " << DLC.modtaboff << ")\n";
+ outs() << " ('nmodtab', " << DLC.nmodtab << ")\n";
+ outs() << " ('extrefsymoff', " << DLC.extrefsymoff << ")\n";
+ outs() << " ('nextrefsyms', " << DLC.nextrefsyms << ")\n";
+ outs() << " ('indirectsymoff', " << DLC.indirectsymoff << ")\n";
+ outs() << " ('nindirectsyms', " << DLC.nindirectsyms << ")\n";
+ outs() << " ('extreloff', " << DLC.extreloff << ")\n";
+ outs() << " ('nextrel', " << DLC.nextrel << ")\n";
+ outs() << " ('locreloff', " << DLC.locreloff << ")\n";
+ outs() << " ('nlocrel', " << DLC.nlocrel << ")\n";
// Dump the indirect symbol table.
outs() << " ('_indirect_symbols', [\n";
- for (unsigned i = 0; i != DLC.NumIndirectSymbolTableEntries; ++i) {
- macho::IndirectSymbolTableEntry ISTE =
- Obj.getIndirectSymbolTableEntry(DLC, i);
+ for (unsigned i = 0; i != DLC.nindirectsyms; ++i) {
+ uint32_t ISTE = Obj.getIndirectSymbolTableEntry(DLC, i);
outs() << " # Indirect Symbol " << i << "\n";
- outs() << " (('symbol_index', "
- << format("0x%x", ISTE.Index) << "),),\n";
+ outs() << " (('symbol_index', " << format("0x%x", ISTE) << "),),\n";
}
outs() << " ])\n";
static int
DumpLinkeditDataCommand(const MachOObjectFile &Obj,
const MachOObjectFile::LoadCommandInfo &LCI) {
- macho::LinkeditDataLoadCommand LLC = Obj.getLinkeditDataLoadCommand(LCI);
- outs() << " ('dataoff', " << LLC.DataOffset << ")\n"
- << " ('datasize', " << LLC.DataSize << ")\n"
+ MachO::linkedit_data_command LLC = Obj.getLinkeditDataLoadCommand(LCI);
+ outs() << " ('dataoff', " << LLC.dataoff << ")\n"
+ << " ('datasize', " << LLC.datasize << ")\n"
<< " ('_addresses', [\n";
SmallVector<uint64_t, 8> Addresses;
- Obj.ReadULEB128s(LLC.DataOffset, Addresses);
+ Obj.ReadULEB128s(LLC.dataoff, Addresses);
for (unsigned i = 0, e = Addresses.size(); i != e; ++i)
outs() << " # Address " << i << '\n'
<< " ('address', " << format("0x%x", Addresses[i]) << "),\n";
static int
DumpDataInCodeDataCommand(const MachOObjectFile &Obj,
const MachOObjectFile::LoadCommandInfo &LCI) {
- macho::LinkeditDataLoadCommand LLC = Obj.getLinkeditDataLoadCommand(LCI);
- outs() << " ('dataoff', " << LLC.DataOffset << ")\n"
- << " ('datasize', " << LLC.DataSize << ")\n"
+ MachO::linkedit_data_command LLC = Obj.getLinkeditDataLoadCommand(LCI);
+ outs() << " ('dataoff', " << LLC.dataoff << ")\n"
+ << " ('datasize', " << LLC.datasize << ")\n"
<< " ('_data_regions', [\n";
- unsigned NumRegions = LLC.DataSize / sizeof(macho::DataInCodeTableEntry);
+ unsigned NumRegions = LLC.datasize / sizeof(MachO::data_in_code_entry);
for (unsigned i = 0; i < NumRegions; ++i) {
- macho::DataInCodeTableEntry DICE =
- Obj.getDataInCodeTableEntry(LLC.DataOffset, i);
+ MachO::data_in_code_entry DICE= Obj.getDataInCodeTableEntry(LLC.dataoff, i);
outs() << " # DICE " << i << "\n"
- << " ('offset', " << DICE.Offset << ")\n"
- << " ('length', " << DICE.Length << ")\n"
- << " ('kind', " << DICE.Kind << ")\n";
+ << " ('offset', " << DICE.offset << ")\n"
+ << " ('length', " << DICE.length << ")\n"
+ << " ('kind', " << DICE.kind << ")\n";
}
outs() <<" ])\n";
static int
DumpLinkerOptionsCommand(const MachOObjectFile &Obj,
const MachOObjectFile::LoadCommandInfo &LCI) {
- macho::LinkerOptionsLoadCommand LOLC = Obj.getLinkerOptionsLoadCommand(LCI);
- outs() << " ('count', " << LOLC.Count << ")\n"
- << " ('_strings', [\n";
-
- uint64_t DataSize = LOLC.Size - sizeof(macho::LinkerOptionsLoadCommand);
- const char *P = LCI.Ptr + sizeof(macho::LinkerOptionsLoadCommand);
- StringRef Data(P, DataSize);
- for (unsigned i = 0; i != LOLC.Count; ++i) {
- std::pair<StringRef,StringRef> Split = Data.split('\0');
- outs() << "\t\"";
- outs().write_escaped(Split.first);
- outs() << "\",\n";
- Data = Split.second;
- }
- outs() <<" ])\n";
+ MachO::linker_options_command LOLC = Obj.getLinkerOptionsLoadCommand(LCI);
+ outs() << " ('count', " << LOLC.count << ")\n"
+ << " ('_strings', [\n";
+
+ uint64_t DataSize = LOLC.cmdsize - sizeof(MachO::linker_options_command);
+ const char *P = LCI.Ptr + sizeof(MachO::linker_options_command);
+ StringRef Data(P, DataSize);
+ for (unsigned i = 0; i != LOLC.count; ++i) {
+ std::pair<StringRef,StringRef> Split = Data.split('\0');
+ outs() << "\t\"";
+ outs().write_escaped(Split.first);
+ outs() << "\",\n";
+ Data = Split.second;
+ }
+ outs() <<" ])\n";
return 0;
}
static int DumpLoadCommand(const MachOObjectFile &Obj,
MachOObjectFile::LoadCommandInfo &LCI) {
- switch (LCI.C.Type) {
- case macho::LCT_Segment:
+ switch (LCI.C.cmd) {
+ case MachO::LC_SEGMENT:
return DumpSegmentCommand(Obj, LCI);
- case macho::LCT_Segment64:
+ case MachO::LC_SEGMENT_64:
return DumpSegment64Command(Obj, LCI);
- case macho::LCT_Symtab:
+ case MachO::LC_SYMTAB:
return DumpSymtabCommand(Obj);
- case macho::LCT_Dysymtab:
+ case MachO::LC_DYSYMTAB:
return DumpDysymtabCommand(Obj);
- case macho::LCT_CodeSignature:
- case macho::LCT_SegmentSplitInfo:
- case macho::LCT_FunctionStarts:
+ case MachO::LC_CODE_SIGNATURE:
+ case MachO::LC_SEGMENT_SPLIT_INFO:
+ case MachO::LC_FUNCTION_STARTS:
return DumpLinkeditDataCommand(Obj, LCI);
- case macho::LCT_DataInCode:
+ case MachO::LC_DATA_IN_CODE:
return DumpDataInCodeDataCommand(Obj, LCI);
- case macho::LCT_LinkerOptions:
+ case MachO::LC_LINKER_OPTIONS:
return DumpLinkerOptionsCommand(Obj, LCI);
default:
- Warning("unknown load command: " + Twine(LCI.C.Type));
+ Warning("unknown load command: " + Twine(LCI.C.cmd));
return 0;
}
}
static int DumpLoadCommand(const MachOObjectFile &Obj, unsigned Index,
MachOObjectFile::LoadCommandInfo &LCI) {
outs() << " # Load Command " << Index << "\n"
- << " (('command', " << LCI.C.Type << ")\n"
- << " ('size', " << LCI.C.Size << ")\n";
+ << " (('command', " << LCI.C.cmd << ")\n"
+ << " ('size', " << LCI.C.cmdsize << ")\n";
int Res = DumpLoadCommand(Obj, LCI);
outs() << " ),\n";
return Res;
}
static void printHeader(const MachOObjectFile *Obj,
- const macho::Header &Header) {
- outs() << "('cputype', " << Header.CPUType << ")\n";
- outs() << "('cpusubtype', " << Header.CPUSubtype << ")\n";
- outs() << "('filetype', " << Header.FileType << ")\n";
- outs() << "('num_load_commands', " << Header.NumLoadCommands << ")\n";
- outs() << "('load_commands_size', " << Header.SizeOfLoadCommands << ")\n";
- outs() << "('flag', " << Header.Flags << ")\n";
+ const MachO::mach_header &Header) {
+ outs() << "('cputype', " << Header.cputype << ")\n";
+ outs() << "('cpusubtype', " << Header.cpusubtype << ")\n";
+ outs() << "('filetype', " << Header.filetype << ")\n";
+ outs() << "('num_load_commands', " << Header.ncmds << ")\n";
+ outs() << "('load_commands_size', " << Header.sizeofcmds << ")\n";
+ outs() << "('flag', " << Header.flags << ")\n";
// Print extended header if 64-bit.
if (Obj->is64Bit()) {
- macho::Header64Ext Header64Ext = Obj->getHeader64Ext();
- outs() << "('reserved', " << Header64Ext.Reserved << ")\n";
+ const MachO::mach_header_64 *Header64 =
+ reinterpret_cast<const MachO::mach_header_64 *>(&Header);
+ outs() << "('reserved', " << Header64->reserved << ")\n";
}
}
return Error("Not a MachO object");
// Print the header
- macho::Header Header = InputObject->getHeader();
- printHeader(InputObject, Header);
+ MachO::mach_header_64 Header64;
+ MachO::mach_header *Header = reinterpret_cast<MachO::mach_header*>(&Header64);
+ if (InputObject->is64Bit())
+ Header64 = InputObject->getHeader64();
+ else
+ *Header = InputObject->getHeader();
+ printHeader(InputObject, *Header);
// Print the load commands.
int Res = 0;
if (DumpLoadCommand(*InputObject, i, Command))
break;
- if (i == Header.NumLoadCommands - 1)
+ if (i == Header->ncmds - 1)
break;
Command = InputObject->getNextLoadCommandInfo(Command);
}
projects / oota-llvm.git / commitdiff