diff options
author | Charles Davis <cdavis5x@gmail.com> | 2013-08-27 05:38:30 +0000 |
---|---|---|
committer | Charles Davis <cdavis5x@gmail.com> | 2013-08-27 05:38:30 +0000 |
commit | f69a29b23a116a3520f185054290c445abf9aa62 (patch) | |
tree | c98b02ef136f3b0b7378b2e883faae39c6177679 /lib/Object | |
parent | 45fbe98c21d06448d1977e8abc95972f4ad86b26 (diff) | |
download | external_llvm-f69a29b23a116a3520f185054290c445abf9aa62.zip external_llvm-f69a29b23a116a3520f185054290c445abf9aa62.tar.gz external_llvm-f69a29b23a116a3520f185054290c445abf9aa62.tar.bz2 |
Revert "Fix the build broken by r189315." and "Move everything depending on Object/MachOFormat.h over to Support/MachO.h."
This reverts commits r189319 and r189315. r189315 broke some tests on what I
believe are big-endian platforms.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@189321 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/Object')
-rw-r--r-- | lib/Object/MachOObjectFile.cpp | 742 | ||||
-rw-r--r-- | lib/Object/MachOUniversal.cpp | 58 |
2 files changed, 397 insertions, 403 deletions
diff --git a/lib/Object/MachOObjectFile.cpp b/lib/Object/MachOObjectFile.cpp index 9df558c..37d6c21 100644 --- a/lib/Object/MachOObjectFile.cpp +++ b/lib/Object/MachOObjectFile.cpp @@ -14,9 +14,11 @@ #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> @@ -29,16 +31,16 @@ using namespace object; namespace llvm { namespace object { -struct nlist_base { - uint32_t n_strx; - uint8_t n_type; - uint8_t n_sect; - uint16_t n_desc; +struct SymbolTableEntryBase { + uint32_t StringIndex; + uint8_t Type; + uint8_t SectionIndex; + uint16_t Flags; }; -struct section_base { - char sectname[16]; - char segname[16]; +struct SectionBase { + char Name[16]; + char SegmentName[16]; }; template<typename T> @@ -50,174 +52,167 @@ template<typename T> static void SwapStruct(T &Value); template<> -void SwapStruct(MachO::any_relocation_info &H) { - SwapValue(H.r_word0); - SwapValue(H.r_word1); +void SwapStruct(macho::RelocationEntry &H) { + SwapValue(H.Word0); + SwapValue(H.Word1); } template<> -void SwapStruct(MachO::load_command &L) { - SwapValue(L.cmd); - SwapValue(L.cmdsize); +void SwapStruct(macho::LoadCommand &L) { + SwapValue(L.Type); + SwapValue(L.Size); } template<> -void SwapStruct(nlist_base &S) { - SwapValue(S.n_strx); - SwapValue(S.n_desc); +void SwapStruct(SymbolTableEntryBase &S) { + SwapValue(S.StringIndex); + SwapValue(S.Flags); } template<> -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); +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); } template<> -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); +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); } template<> -void SwapStruct(MachO::nlist &S) { - SwapValue(S.n_strx); - SwapValue(S.n_desc); - SwapValue(S.n_value); +void SwapStruct(macho::SymbolTableEntry &S) { + SwapValue(S.StringIndex); + SwapValue(S.Flags); + SwapValue(S.Value); } template<> -void SwapStruct(MachO::nlist_64 &S) { - SwapValue(S.n_strx); - SwapValue(S.n_desc); - SwapValue(S.n_value); +void SwapStruct(macho::Symbol64TableEntry &S) { + SwapValue(S.StringIndex); + SwapValue(S.Flags); + SwapValue(S.Value); } template<> -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); +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); } template<> -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); +void SwapStruct(macho::Header64Ext &E) { + SwapValue(E.Reserved); } template<> -void SwapStruct(MachO::symtab_command &C) { - SwapValue(C.cmd); - SwapValue(C.cmdsize); - SwapValue(C.symoff); - SwapValue(C.nsyms); - SwapValue(C.stroff); - SwapValue(C.strsize); +void SwapStruct(macho::SymtabLoadCommand &C) { + SwapValue(C.Type); + SwapValue(C.Size); + SwapValue(C.SymbolTableOffset); + SwapValue(C.NumSymbolTableEntries); + SwapValue(C.StringTableOffset); + SwapValue(C.StringTableSize); } template<> -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); +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); } template<> -void SwapStruct(MachO::linkedit_data_command &C) { - SwapValue(C.cmd); - SwapValue(C.cmdsize); - SwapValue(C.dataoff); - SwapValue(C.datasize); +void SwapStruct(macho::LinkeditDataLoadCommand &C) { + SwapValue(C.Type); + SwapValue(C.Size); + SwapValue(C.DataOffset); + SwapValue(C.DataSize); } template<> -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); +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); } template<> -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); +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); } template<> -void SwapStruct(uint32_t &C) { - SwapValue(C); +void SwapStruct(macho::IndirectSymbolTableEntry &C) { + SwapValue(C.Index); } template<> -void SwapStruct(MachO::linker_options_command &C) { - SwapValue(C.cmd); - SwapValue(C.cmdsize); - SwapValue(C.count); +void SwapStruct(macho::LinkerOptionsLoadCommand &C) { + SwapValue(C.Type); + SwapValue(C.Size); + SwapValue(C.Count); } template<> -void SwapStruct(MachO::data_in_code_entry &C) { - SwapValue(C.offset); - SwapValue(C.length); - SwapValue(C.kind); +void SwapStruct(macho::DataInCodeTableEntry &C) { + SwapValue(C.Offset); + SwapValue(C.Length); + SwapValue(C.Kind); } template<typename T> @@ -233,11 +228,11 @@ static uint32_t getSegmentLoadCommandNumSections(const MachOObjectFile *O, const MachOObjectFile::LoadCommandInfo &L) { if (O->is64Bit()) { - MachO::segment_command_64 S = O->getSegment64LoadCommand(L); - return S.nsects; + macho::Segment64LoadCommand S = O->getSegment64LoadCommand(L); + return S.NumSections; } - MachO::segment_command S = O->getSegmentLoadCommand(L); - return S.nsects; + macho::SegmentLoadCommand S = O->getSegmentLoadCommand(L); + return S.NumSections; } static const char * @@ -246,23 +241,23 @@ getSectionPtr(const MachOObjectFile *O, MachOObjectFile::LoadCommandInfo L, uintptr_t CommandAddr = reinterpret_cast<uintptr_t>(L.Ptr); bool Is64 = O->is64Bit(); - unsigned SegmentLoadSize = Is64 ? sizeof(MachO::segment_command_64) : - sizeof(MachO::segment_command); - unsigned SectionSize = Is64 ? sizeof(MachO::section_64) : - sizeof(MachO::section); + unsigned SegmentLoadSize = Is64 ? sizeof(macho::Segment64LoadCommand) : + sizeof(macho::SegmentLoadCommand); + unsigned SectionSize = Is64 ? sizeof(macho::Section64) : + sizeof(macho::Section); uintptr_t SectionAddr = CommandAddr + SegmentLoadSize + Sec * SectionSize; - return reinterpret_cast<const char *>(SectionAddr); + return reinterpret_cast<const char*>(SectionAddr); } static const char *getPtr(const MachOObjectFile *O, size_t Offset) { return O->getData().substr(Offset, 1).data(); } -static nlist_base +static SymbolTableEntryBase getSymbolTableEntryBase(const MachOObjectFile *O, DataRefImpl DRI) { const char *P = reinterpret_cast<const char *>(DRI.p); - return getStruct<nlist_base>(O, P); + return getStruct<SymbolTableEntryBase>(O, P); } static StringRef parseSegmentOrSectionName(const char *P) { @@ -290,11 +285,11 @@ static void advanceTo(T &it, size_t Val) { } static unsigned getCPUType(const MachOObjectFile *O) { - return O->getHeader().cputype; + return O->getHeader().CPUType; } static void printRelocationTargetName(const MachOObjectFile *O, - const MachO::any_relocation_info &RE, + const macho::RelocationEntry &RE, raw_string_ostream &fmt) { bool IsScattered = O->isRelocationScattered(RE); @@ -362,61 +357,59 @@ static void printRelocationTargetName(const MachOObjectFile *O, fmt << S; } -static uint32_t -getPlainRelocationAddress(const MachO::any_relocation_info &RE) { - return RE.r_word0; +static uint32_t getPlainRelocationAddress(const macho::RelocationEntry &RE) { + return RE.Word0; } static unsigned -getScatteredRelocationAddress(const MachO::any_relocation_info &RE) { - return RE.r_word0 & 0xffffff; +getScatteredRelocationAddress(const macho::RelocationEntry &RE) { + return RE.Word0 & 0xffffff; } static bool getPlainRelocationPCRel(const MachOObjectFile *O, - const MachO::any_relocation_info &RE) { + const macho::RelocationEntry &RE) { if (O->isLittleEndian()) - return (RE.r_word1 >> 24) & 1; - return (RE.r_word1 >> 7) & 1; + return (RE.Word1 >> 24) & 1; + return (RE.Word1 >> 7) & 1; } static bool getScatteredRelocationPCRel(const MachOObjectFile *O, - const MachO::any_relocation_info &RE) { - return (RE.r_word0 >> 30) & 1; + const macho::RelocationEntry &RE) { + return (RE.Word0 >> 30) & 1; } static unsigned getPlainRelocationLength(const MachOObjectFile *O, - const MachO::any_relocation_info &RE) { + const macho::RelocationEntry &RE) { if (O->isLittleEndian()) - return (RE.r_word1 >> 25) & 3; - return (RE.r_word1 >> 5) & 3; + return (RE.Word1 >> 25) & 3; + return (RE.Word1 >> 5) & 3; } static unsigned -getScatteredRelocationLength(const MachO::any_relocation_info &RE) { - return (RE.r_word0 >> 28) & 3; +getScatteredRelocationLength(const macho::RelocationEntry &RE) { + return (RE.Word0 >> 28) & 3; } static unsigned getPlainRelocationType(const MachOObjectFile *O, - const MachO::any_relocation_info &RE) { + const macho::RelocationEntry &RE) { if (O->isLittleEndian()) - return RE.r_word1 >> 28; - return RE.r_word1 & 0xf; + return RE.Word1 >> 28; + return RE.Word1 & 0xf; } -static unsigned -getScatteredRelocationType(const MachO::any_relocation_info &RE) { - return (RE.r_word0 >> 24) & 0xf; +static unsigned getScatteredRelocationType(const macho::RelocationEntry &RE) { + return (RE.Word0 >> 24) & 0xf; } static uint32_t getSectionFlags(const MachOObjectFile *O, DataRefImpl Sec) { if (O->is64Bit()) { - MachO::section_64 Sect = O->getSection64(Sec); - return Sect.flags; + macho::Section64 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, @@ -424,22 +417,22 @@ MachOObjectFile::MachOObjectFile(MemoryBuffer *Object, error_code &ec) : ObjectFile(getMachOType(IsLittleEndian, Is64bits), Object), SymtabLoadCmd(NULL), DysymtabLoadCmd(NULL), DataInCodeLoadCmd(NULL) { - uint32_t LoadCommandCount = this->getHeader().ncmds; - MachO::LoadCommandType SegmentLoadType = is64Bit() ? - MachO::LC_SEGMENT_64 : MachO::LC_SEGMENT; + uint32_t LoadCommandCount = this->getHeader().NumLoadCommands; + macho::LoadCommandType SegmentLoadType = is64Bit() ? + macho::LCT_Segment64 : macho::LCT_Segment; MachOObjectFile::LoadCommandInfo Load = getFirstLoadCommandInfo(); for (unsigned I = 0; ; ++I) { - if (Load.C.cmd == MachO::LC_SYMTAB) { + if (Load.C.Type == macho::LCT_Symtab) { assert(!SymtabLoadCmd && "Multiple symbol tables"); SymtabLoadCmd = Load.Ptr; - } else if (Load.C.cmd == MachO::LC_DYSYMTAB) { + } else if (Load.C.Type == macho::LCT_Dysymtab) { assert(!DysymtabLoadCmd && "Multiple dynamic symbol tables"); DysymtabLoadCmd = Load.Ptr; - } else if (Load.C.cmd == MachO::LC_DATA_IN_CODE) { + } else if (Load.C.Type == macho::LCT_DataInCode) { assert(!DataInCodeLoadCmd && "Multiple data in code tables"); DataInCodeLoadCmd = Load.Ptr; - } else if (Load.C.cmd == SegmentLoadType) { + } else if (Load.C.Type == SegmentLoadType) { uint32_t NumSections = getSegmentLoadCommandNumSections(this, Load); for (unsigned J = 0; J < NumSections; ++J) { const char *Sec = getSectionPtr(this, Load, J); @@ -457,8 +450,8 @@ MachOObjectFile::MachOObjectFile(MemoryBuffer *Object, error_code MachOObjectFile::getSymbolNext(DataRefImpl Symb, SymbolRef &Res) const { unsigned SymbolTableEntrySize = is64Bit() ? - sizeof(MachO::nlist_64) : - sizeof(MachO::nlist); + sizeof(macho::Symbol64TableEntry) : + sizeof(macho::SymbolTableEntry); Symb.p += SymbolTableEntrySize; Res = SymbolRef(Symb, this); return object_error::success; @@ -467,8 +460,8 @@ error_code MachOObjectFile::getSymbolNext(DataRefImpl Symb, error_code MachOObjectFile::getSymbolName(DataRefImpl Symb, StringRef &Res) const { StringRef StringTable = getStringTableData(); - nlist_base Entry = getSymbolTableEntryBase(this, Symb); - const char *Start = &StringTable.data()[Entry.n_strx]; + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb); + const char *Start = &StringTable.data()[Entry.StringIndex]; Res = StringRef(Start); return object_error::success; } @@ -476,11 +469,11 @@ error_code MachOObjectFile::getSymbolName(DataRefImpl Symb, error_code MachOObjectFile::getSymbolAddress(DataRefImpl Symb, uint64_t &Res) const { if (is64Bit()) { - MachO::nlist_64 Entry = getSymbol64TableEntry(Symb); - Res = Entry.n_value; + macho::Symbol64TableEntry Entry = getSymbol64TableEntry(Symb); + Res = Entry.Value; } else { - MachO::nlist Entry = getSymbolTableEntry(Symb); - Res = Entry.n_value; + macho::SymbolTableEntry Entry = getSymbolTableEntry(Symb); + Res = Entry.Value; } return object_error::success; } @@ -488,18 +481,18 @@ error_code MachOObjectFile::getSymbolAddress(DataRefImpl Symb, error_code MachOObjectFile::getSymbolFileOffset(DataRefImpl Symb, uint64_t &Res) const { - nlist_base Entry = getSymbolTableEntryBase(this, Symb); + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb); getSymbolAddress(Symb, Res); - if (Entry.n_sect) { + if (Entry.SectionIndex) { uint64_t Delta; DataRefImpl SecRel; - SecRel.d.a = Entry.n_sect-1; + SecRel.d.a = Entry.SectionIndex-1; if (is64Bit()) { - MachO::section_64 Sec = getSection64(SecRel); - Delta = Sec.offset - Sec.addr; + macho::Section64 Sec = getSection64(SecRel); + Delta = Sec.Offset - Sec.Address; } else { - MachO::section Sec = getSection(SecRel); - Delta = Sec.offset - Sec.addr; + macho::Section Sec = getSection(SecRel); + Delta = Sec.Offset - Sec.Address; } Res += Delta; @@ -513,8 +506,8 @@ error_code MachOObjectFile::getSymbolAlignment(DataRefImpl DRI, uint32_t flags; this->getSymbolFlags(DRI, flags); if (flags & SymbolRef::SF_Common) { - nlist_base Entry = getSymbolTableEntryBase(this, DRI); - Result = 1 << MachO::GET_COMM_ALIGN(Entry.n_desc); + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, DRI); + Result = 1 << MachO::GET_COMM_ALIGN(Entry.Flags); } else { Result = 0; } @@ -527,13 +520,13 @@ error_code MachOObjectFile::getSymbolSize(DataRefImpl DRI, uint64_t EndOffset = 0; uint8_t SectionIndex; - nlist_base Entry = getSymbolTableEntryBase(this, DRI); + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, DRI); uint64_t Value; getSymbolAddress(DRI, Value); BeginOffset = Value; - SectionIndex = Entry.n_sect; + SectionIndex = Entry.SectionIndex; if (!SectionIndex) { uint32_t flags = SymbolRef::SF_None; this->getSymbolFlags(DRI, flags); @@ -551,7 +544,7 @@ error_code MachOObjectFile::getSymbolSize(DataRefImpl DRI, DataRefImpl DRI = I->getRawDataRefImpl(); Entry = getSymbolTableEntryBase(this, DRI); getSymbolAddress(DRI, Value); - if (Entry.n_sect == SectionIndex && Value > BeginOffset) + if (Entry.SectionIndex == SectionIndex && Value > BeginOffset) if (!EndOffset || Value < EndOffset) EndOffset = Value; } @@ -569,8 +562,8 @@ error_code MachOObjectFile::getSymbolSize(DataRefImpl DRI, error_code MachOObjectFile::getSymbolType(DataRefImpl Symb, SymbolRef::Type &Res) const { - nlist_base Entry = getSymbolTableEntryBase(this, Symb); - uint8_t n_type = Entry.n_type; + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb); + uint8_t n_type = Entry.Type; Res = SymbolRef::ST_Other; @@ -593,17 +586,17 @@ error_code MachOObjectFile::getSymbolType(DataRefImpl Symb, error_code MachOObjectFile::getSymbolNMTypeChar(DataRefImpl Symb, char &Res) const { - nlist_base Entry = getSymbolTableEntryBase(this, Symb); - uint8_t Type = Entry.n_type; - uint16_t Flags = Entry.n_desc; + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb); + uint8_t Type = Entry.Type; + uint16_t Flags = Entry.Flags; char Char; - switch (Type & MachO::N_TYPE) { - case MachO::N_UNDF: + switch (Type & macho::STF_TypeMask) { + case macho::STT_Undefined: Char = 'u'; break; - case MachO::N_ABS: - case MachO::N_SECT: + case macho::STT_Absolute: + case macho::STT_Section: Char = 's'; break; default: @@ -611,7 +604,7 @@ error_code MachOObjectFile::getSymbolNMTypeChar(DataRefImpl Symb, break; } - if (Flags & (MachO::N_EXT | MachO::N_PEXT)) + if (Flags & (macho::STF_External | macho::STF_PrivateExtern)) Char = toupper(static_cast<unsigned char>(Char)); Res = Char; return object_error::success; @@ -619,10 +612,10 @@ error_code MachOObjectFile::getSymbolNMTypeChar(DataRefImpl Symb, error_code MachOObjectFile::getSymbolFlags(DataRefImpl DRI, uint32_t &Result) const { - nlist_base Entry = getSymbolTableEntryBase(this, DRI); + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, DRI); - uint8_t MachOType = Entry.n_type; - uint16_t MachOFlags = Entry.n_desc; + uint8_t MachOType = Entry.Type; + uint16_t MachOFlags = Entry.Flags; // TODO: Correctly set SF_ThreadLocal Result = SymbolRef::SF_None; @@ -630,7 +623,7 @@ error_code MachOObjectFile::getSymbolFlags(DataRefImpl DRI, if ((MachOType & MachO::N_TYPE) == MachO::N_UNDF) Result |= SymbolRef::SF_Undefined; - if (MachOFlags & MachO::N_STAB) + if (MachOFlags & macho::STF_StabsEntryMask) Result |= SymbolRef::SF_FormatSpecific; if (MachOType & MachO::N_EXT) { @@ -655,8 +648,8 @@ error_code MachOObjectFile::getSymbolFlags(DataRefImpl DRI, error_code MachOObjectFile::getSymbolSection(DataRefImpl Symb, section_iterator &Res) const { - nlist_base Entry = getSymbolTableEntryBase(this, Symb); - uint8_t index = Entry.n_sect; + SymbolTableEntryBase Entry = getSymbolTableEntryBase(this, Symb); + uint8_t index = Entry.SectionIndex; if (index == 0) { Res = end_sections(); @@ -691,11 +684,11 @@ MachOObjectFile::getSectionName(DataRefImpl Sec, StringRef &Result) const { error_code MachOObjectFile::getSectionAddress(DataRefImpl Sec, uint64_t &Res) const { if (is64Bit()) { - MachO::section_64 Sect = getSection64(Sec); - Res = Sect.addr; + macho::Section64 Sect = getSection64(Sec); + Res = Sect.Address; } else { - MachO::section Sect = getSection(Sec); - Res = Sect.addr; + macho::Section Sect = getSection(Sec); + Res = Sect.Address; } return object_error::success; } @@ -703,11 +696,11 @@ MachOObjectFile::getSectionAddress(DataRefImpl Sec, uint64_t &Res) const { error_code MachOObjectFile::getSectionSize(DataRefImpl Sec, uint64_t &Res) const { if (is64Bit()) { - MachO::section_64 Sect = getSection64(Sec); - Res = Sect.size; + macho::Section64 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; @@ -719,13 +712,13 @@ MachOObjectFile::getSectionContents(DataRefImpl Sec, StringRef &Res) const { uint64_t Size; if (is64Bit()) { - MachO::section_64 Sect = getSection64(Sec); - Offset = Sect.offset; - Size = Sect.size; + macho::Section64 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); @@ -736,11 +729,11 @@ error_code MachOObjectFile::getSectionAlignment(DataRefImpl Sec, uint64_t &Res) const { uint32_t Align; if (is64Bit()) { - MachO::section_64 Sect = getSection64(Sec); - Align = Sect.align; + macho::Section64 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; @@ -750,7 +743,7 @@ MachOObjectFile::getSectionAlignment(DataRefImpl Sec, uint64_t &Res) const { error_code MachOObjectFile::isSectionText(DataRefImpl Sec, bool &Res) const { uint32_t Flags = getSectionFlags(this, Sec); - Res = Flags & MachO::S_ATTR_PURE_INSTRUCTIONS; + Res = Flags & macho::SF_PureInstructions; return object_error::success; } @@ -826,11 +819,11 @@ MachOObjectFile::sectionContainsSymbol(DataRefImpl Sec, DataRefImpl Symb, relocation_iterator MachOObjectFile::getSectionRelBegin(DataRefImpl Sec) const { uint32_t Offset; if (is64Bit()) { - MachO::section_64 Sect = getSection64(Sec); - Offset = Sect.reloff; + macho::Section64 Sect = getSection64(Sec); + Offset = Sect.RelocationTableOffset; } else { - MachO::section Sect = getSection(Sec); - Offset = Sect.reloff; + macho::Section Sect = getSection(Sec); + Offset = Sect.RelocationTableOffset; } DataRefImpl Ret; @@ -843,17 +836,17 @@ MachOObjectFile::getSectionRelEnd(DataRefImpl Sec) const { uint32_t Offset; uint32_t Num; if (is64Bit()) { - MachO::section_64 Sect = getSection64(Sec); - Offset = Sect.reloff; - Num = Sect.nreloc; + macho::Section64 Sect = getSection64(Sec); + Offset = Sect.RelocationTableOffset; + Num = Sect.NumRelocationTableEntries; } else { - MachO::section Sect = getSection(Sec); - Offset = Sect.reloff; - Num = Sect.nreloc; + macho::Section Sect = getSection(Sec); + Offset = Sect.RelocationTableOffset; + Num = Sect.NumRelocationTableEntries; } - const MachO::any_relocation_info *P = - reinterpret_cast<const MachO::any_relocation_info *>(getPtr(this, Offset)); + const macho::RelocationEntry *P = + reinterpret_cast<const macho::RelocationEntry*>(getPtr(this, Offset)); DataRefImpl Ret; Ret.p = reinterpret_cast<uintptr_t>(P + Num); @@ -862,8 +855,8 @@ MachOObjectFile::getSectionRelEnd(DataRefImpl Sec) const { error_code MachOObjectFile::getRelocationNext(DataRefImpl Rel, RelocationRef &Res) const { - const MachO::any_relocation_info *P = - reinterpret_cast<const MachO::any_relocation_info *>(Rel.p); + const macho::RelocationEntry *P = + reinterpret_cast<const macho::RelocationEntry *>(Rel.p); Rel.p = reinterpret_cast<uintptr_t>(P + 1); Res = RelocationRef(Rel, this); return object_error::success; @@ -876,24 +869,24 @@ MachOObjectFile::getRelocationAddress(DataRefImpl Rel, uint64_t &Res) const { error_code MachOObjectFile::getRelocationOffset(DataRefImpl Rel, uint64_t &Res) const { - MachO::any_relocation_info RE = getRelocation(Rel); + macho::RelocationEntry RE = getRelocation(Rel); Res = getAnyRelocationAddress(RE); return object_error::success; } symbol_iterator MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const { - MachO::any_relocation_info RE = getRelocation(Rel); + macho::RelocationEntry RE = getRelocation(Rel); uint32_t SymbolIdx = getPlainRelocationSymbolNum(RE); bool isExtern = getPlainRelocationExternal(RE); if (!isExtern) return end_symbols(); - MachO::symtab_command S = getSymtabLoadCommand(); + macho::SymtabLoadCommand S = getSymtabLoadCommand(); unsigned SymbolTableEntrySize = is64Bit() ? - sizeof(MachO::nlist_64) : - sizeof(MachO::nlist); - uint64_t Offset = S.symoff + SymbolIdx * SymbolTableEntrySize; + sizeof(macho::Symbol64TableEntry) : + sizeof(macho::SymbolTableEntry); + uint64_t Offset = S.SymbolTableOffset + SymbolIdx * SymbolTableEntrySize; DataRefImpl Sym; Sym.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset)); return symbol_iterator(SymbolRef(Sym, this)); @@ -901,7 +894,7 @@ MachOObjectFile::getRelocationSymbol(DataRefImpl Rel) const { error_code MachOObjectFile::getRelocationType(DataRefImpl Rel, uint64_t &Res) const { - MachO::any_relocation_info RE = getRelocation(Rel); + macho::RelocationEntry RE = getRelocation(Rel); Res = getAnyRelocationType(RE); return object_error::success; } @@ -1002,7 +995,7 @@ MachOObjectFile::getRelocationTypeName(DataRefImpl Rel, error_code MachOObjectFile::getRelocationValueString(DataRefImpl Rel, SmallVectorImpl<char> &Result) const { - MachO::any_relocation_info RE = getRelocation(Rel); + macho::RelocationEntry RE = getRelocation(Rel); unsigned Arch = this->getArch(); @@ -1019,47 +1012,47 @@ MachOObjectFile::getRelocationValueString(DataRefImpl Rel, bool isPCRel = getAnyRelocationPCRel(RE); switch (Type) { - case MachO::X86_64_RELOC_GOT_LOAD: - case MachO::X86_64_RELOC_GOT: { + case macho::RIT_X86_64_GOTLoad: // X86_64_RELOC_GOT_LOAD + case macho::RIT_X86_64_GOT: { // X86_64_RELOC_GOT printRelocationTargetName(this, RE, fmt); fmt << "@GOT"; if (isPCRel) fmt << "PCREL"; break; } - case MachO::X86_64_RELOC_SUBTRACTOR: { + case macho::RIT_X86_64_Subtractor: { // X86_64_RELOC_SUBTRACTOR DataRefImpl RelNext = Rel; RelNext.d.a++; - MachO::any_relocation_info RENext = getRelocation(RelNext); + macho::RelocationEntry RENext = getRelocation(RelNext); - // X86_64_RELOC_SUBTRACTOR must be followed by a relocation of type + // X86_64_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 != MachO::X86_64_RELOC_UNSIGNED) + if (RType != 0) report_fatal_error("Expected X86_64_RELOC_UNSIGNED after " "X86_64_RELOC_SUBTRACTOR."); - // The X86_64_RELOC_UNSIGNED contains the minuend symbol; - // X86_64_RELOC_SUBTRACTOR contains the subtrahend. + // The X86_64_RELOC_UNSIGNED contains the minuend symbol, + // X86_64_SUBTRACTOR contains to the subtrahend. printRelocationTargetName(this, RENext, fmt); fmt << "-"; printRelocationTargetName(this, RE, fmt); break; } - case MachO::X86_64_RELOC_TLV: + case macho::RIT_X86_64_TLV: printRelocationTargetName(this, RE, fmt); fmt << "@TLV"; if (isPCRel) fmt << "P"; break; - case MachO::X86_64_RELOC_SIGNED_1: + case macho::RIT_X86_64_Signed1: // X86_64_RELOC_SIGNED1 printRelocationTargetName(this, RE, fmt); fmt << "-1"; break; - case MachO::X86_64_RELOC_SIGNED_2: + case macho::RIT_X86_64_Signed2: // X86_64_RELOC_SIGNED2 printRelocationTargetName(this, RE, fmt); fmt << "-2"; break; - case MachO::X86_64_RELOC_SIGNED_4: + case macho::RIT_X86_64_Signed4: // X86_64_RELOC_SIGNED4 printRelocationTargetName(this, RE, fmt); fmt << "-4"; break; @@ -1072,18 +1065,18 @@ MachOObjectFile::getRelocationValueString(DataRefImpl Rel, Arch == Triple::ppc) { // Generic relocation types... switch (Type) { - case MachO::GENERIC_RELOC_PAIR: // prints no info + case macho::RIT_Pair: // GENERIC_RELOC_PAIR - prints no info return object_error::success; - case MachO::GENERIC_RELOC_SECTDIFF: { + case macho::RIT_Difference: { // GENERIC_RELOC_SECTDIFF DataRefImpl RelNext = Rel; RelNext.d.a++; - MachO::any_relocation_info RENext = getRelocation(RelNext); + macho::RelocationEntry RENext = getRelocation(RelNext); // X86 sect diff's must be followed by a relocation of type // GENERIC_RELOC_PAIR. unsigned RType = getAnyRelocationType(RENext); - if (RType != MachO::GENERIC_RELOC_PAIR) + if (RType != 1) report_fatal_error("Expected GENERIC_RELOC_PAIR after " "GENERIC_RELOC_SECTDIFF."); @@ -1095,16 +1088,18 @@ MachOObjectFile::getRelocationValueString(DataRefImpl Rel, } 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::GENERIC_RELOC_LOCAL_SECTDIFF: { + case macho::RIT_Generic_LocalDifference:{// GENERIC_RELOC_LOCAL_SECTDIFF DataRefImpl RelNext = Rel; RelNext.d.a++; - MachO::any_relocation_info RENext = getRelocation(RelNext); + macho::RelocationEntry RENext = getRelocation(RelNext); // X86 sect diff's must be followed by a relocation of type // GENERIC_RELOC_PAIR. unsigned RType = getAnyRelocationType(RENext); - if (RType != MachO::GENERIC_RELOC_PAIR) + if (RType != 1) report_fatal_error("Expected GENERIC_RELOC_PAIR after " "GENERIC_RELOC_LOCAL_SECTDIFF."); @@ -1113,7 +1108,7 @@ MachOObjectFile::getRelocationValueString(DataRefImpl Rel, printRelocationTargetName(this, RENext, fmt); break; } - case MachO::GENERIC_RELOC_TLV: { + case macho::RIT_Generic_TLV: { printRelocationTargetName(this, RE, fmt); fmt << "@TLV"; if (IsPCRel) fmt << "P"; @@ -1124,8 +1119,8 @@ MachOObjectFile::getRelocationValueString(DataRefImpl Rel, } } else { // ARM-specific relocations switch (Type) { - case MachO::ARM_RELOC_HALF: - case MachO::ARM_RELOC_HALF_SECTDIFF: { + case macho::RIT_ARM_Half: // ARM_RELOC_HALF + case macho::RIT_ARM_HalfDifference: { // 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; @@ -1138,14 +1133,14 @@ MachOObjectFile::getRelocationValueString(DataRefImpl Rel, DataRefImpl RelNext = Rel; RelNext.d.a++; - MachO::any_relocation_info RENext = getRelocation(RelNext); + macho::RelocationEntry RENext = getRelocation(RelNext); // ARM half relocs must be followed by a relocation of type // ARM_RELOC_PAIR. unsigned RType = getAnyRelocationType(RENext); - if (RType != MachO::ARM_RELOC_PAIR) + if (RType != 1) report_fatal_error("Expected ARM_RELOC_PAIR after " - "ARM_RELOC_HALF"); + "GENERIC_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 @@ -1154,7 +1149,7 @@ MachOObjectFile::getRelocationValueString(DataRefImpl Rel, // ARM_RELOC_HALF_SECTDIFF encodes the second section in the // symbol/section pointer of the follow-on relocation. - if (Type == MachO::ARM_RELOC_HALF_SECTDIFF) { + if (Type == macho::RIT_ARM_HalfDifference) { fmt << "-"; printRelocationTargetName(this, RENext, fmt); } @@ -1186,16 +1181,16 @@ MachOObjectFile::getRelocationHidden(DataRefImpl Rel, bool &Result) const { // 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::GENERIC_RELOC_PAIR) Result = true; + if (Type == macho::RIT_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::X86_64_RELOC_UNSIGNED && Rel.d.a > 0) { + if (Type == macho::RIT_X86_64_Unsigned && Rel.d.a > 0) { DataRefImpl RelPrev = Rel; RelPrev.d.a--; uint64_t PrevType; getRelocationType(RelPrev, PrevType); - if (PrevType == MachO::X86_64_RELOC_SUBTRACTOR) + if (PrevType == macho::RIT_X86_64_Subtractor) Result = true; } } @@ -1218,8 +1213,8 @@ symbol_iterator MachOObjectFile::begin_symbols() const { if (!SymtabLoadCmd) return symbol_iterator(SymbolRef(DRI, this)); - MachO::symtab_command Symtab = getSymtabLoadCommand(); - DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.symoff)); + macho::SymtabLoadCommand Symtab = getSymtabLoadCommand(); + DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Symtab.SymbolTableOffset)); return symbol_iterator(SymbolRef(DRI, this)); } @@ -1228,12 +1223,12 @@ symbol_iterator MachOObjectFile::end_symbols() const { if (!SymtabLoadCmd) return symbol_iterator(SymbolRef(DRI, this)); - MachO::symtab_command Symtab = getSymtabLoadCommand(); + macho::SymtabLoadCommand Symtab = getSymtabLoadCommand(); unsigned SymbolTableEntrySize = is64Bit() ? - sizeof(MachO::nlist_64) : - sizeof(MachO::nlist); - unsigned Offset = Symtab.symoff + - Symtab.nsyms * SymbolTableEntrySize; + sizeof(macho::Symbol64TableEntry) : + sizeof(macho::SymbolTableEntry); + unsigned Offset = Symtab.SymbolTableOffset + + Symtab.NumSymbolTableEntries * SymbolTableEntrySize; DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset)); return symbol_iterator(SymbolRef(DRI, this)); } @@ -1328,7 +1323,7 @@ unsigned MachOObjectFile::getArch() const { StringRef MachOObjectFile::getLoadName() const { // TODO: Implement - report_fatal_error("Load name unimplemented in MachOObjectFile"); + report_fatal_error("get_load_name() unimplemented in MachOObjectFile"); } relocation_iterator MachOObjectFile::getSectionRelBegin(unsigned Index) const { @@ -1348,8 +1343,8 @@ dice_iterator MachOObjectFile::begin_dices() const { if (!DataInCodeLoadCmd) return dice_iterator(DiceRef(DRI, this)); - MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand(); - DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.dataoff)); + macho::LinkeditDataLoadCommand DicLC = getDataInCodeLoadCommand(); + DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, DicLC.DataOffset)); return dice_iterator(DiceRef(DRI, this)); } @@ -1358,8 +1353,8 @@ dice_iterator MachOObjectFile::end_dices() const { if (!DataInCodeLoadCmd) return dice_iterator(DiceRef(DRI, this)); - MachO::linkedit_data_command DicLC = getDataInCodeLoadCommand(); - unsigned Offset = DicLC.dataoff + DicLC.datasize; + macho::LinkeditDataLoadCommand DicLC = getDataInCodeLoadCommand(); + unsigned Offset = DicLC.DataOffset + DicLC.DataSize; DRI.p = reinterpret_cast<uintptr_t>(getPtr(this, Offset)); return dice_iterator(DiceRef(DRI, this)); } @@ -1372,82 +1367,80 @@ MachOObjectFile::getSectionFinalSegmentName(DataRefImpl Sec) const { ArrayRef<char> MachOObjectFile::getSectionRawName(DataRefImpl Sec) const { - const section_base *Base = - reinterpret_cast<const section_base *>(Sections[Sec.d.a]); - return ArrayRef<char>(Base->sectname); + const SectionBase *Base = + reinterpret_cast<const SectionBase*>(Sections[Sec.d.a]); + return ArrayRef<char>(Base->Name); } ArrayRef<char> MachOObjectFile::getSectionRawFinalSegmentName(DataRefImpl Sec) const { - const section_base *Base = - reinterpret_cast<const section_base *>(Sections[Sec.d.a]); - return ArrayRef<char>(Base->segname); + const SectionBase *Base = + reinterpret_cast<const SectionBase*>(Sections[Sec.d.a]); + return ArrayRef<char>(Base->SegmentName); } bool -MachOObjectFile::isRelocationScattered(const MachO::any_relocation_info &RE) +MachOObjectFile::isRelocationScattered(const macho::RelocationEntry &RE) const { - if (getCPUType(this) == MachO::CPU_TYPE_X86_64) + if (getCPUType(this) == llvm::MachO::CPU_TYPE_X86_64) return false; - return getPlainRelocationAddress(RE) & MachO::R_SCATTERED; + return getPlainRelocationAddress(RE) & macho::RF_Scattered; } unsigned MachOObjectFile::getPlainRelocationSymbolNum( - const MachO::any_relocation_info &RE) const { + const macho::RelocationEntry &RE) const { if (isLittleEndian()) - return RE.r_word1 & 0xffffff; - return RE.r_word1 >> 8; + return RE.Word1 & 0xffffff; + return RE.Word1 >> 8; } bool MachOObjectFile::getPlainRelocationExternal( - const MachO::any_relocation_info &RE) const { + const macho::RelocationEntry &RE) const { if (isLittleEndian()) - return (RE.r_word1 >> 27) & 1; - return (RE.r_word1 >> 4) & 1; + return (RE.Word1 >> 27) & 1; + return (RE.Word1 >> 4) & 1; } bool MachOObjectFile::getScatteredRelocationScattered( - const MachO::any_relocation_info &RE) const { - return RE.r_word0 >> 31; + const macho::RelocationEntry &RE) const { + return RE.Word0 >> 31; } uint32_t MachOObjectFile::getScatteredRelocationValue( - const MachO::any_relocation_info &RE) const { - return RE.r_word1; + const macho::RelocationEntry &RE) const { + return RE.Word1; } unsigned MachOObjectFile::getAnyRelocationAddress( - const MachO::any_relocation_info &RE) const { + const macho::RelocationEntry &RE) const { if (isRelocationScattered(RE)) return getScatteredRelocationAddress(RE); return getPlainRelocationAddress(RE); } -unsigned MachOObjectFile::getAnyRelocationPCRel( - const MachO::any_relocation_info &RE) const { +unsigned +MachOObjectFile::getAnyRelocationPCRel(const macho::RelocationEntry &RE) const { if (isRelocationScattered(RE)) return getScatteredRelocationPCRel(this, RE); return getPlainRelocationPCRel(this, RE); } unsigned MachOObjectFile::getAnyRelocationLength( - const MachO::any_relocation_info &RE) const { + const macho::RelocationEntry &RE) const { if (isRelocationScattered(RE)) return getScatteredRelocationLength(RE); return getPlainRelocationLength(this, RE); } unsigned -MachOObjectFile::getAnyRelocationType( - const MachO::any_relocation_info &RE) const { +MachOObjectFile::getAnyRelocationType(const macho::RelocationEntry &RE) const { if (isRelocationScattered(RE)) return getScatteredRelocationType(RE); return getPlainRelocationType(this, RE); } SectionRef -MachOObjectFile::getRelocationSection( - const MachO::any_relocation_info &RE) const { +MachOObjectFile::getRelocationSection(const macho::RelocationEntry &RE) const { if (isRelocationScattered(RE) || getPlainRelocationExternal(RE)) return *end_sections(); unsigned SecNum = getPlainRelocationSymbolNum(RE) - 1; @@ -1460,132 +1453,133 @@ MachOObjectFile::LoadCommandInfo MachOObjectFile::getFirstLoadCommandInfo() const { MachOObjectFile::LoadCommandInfo Load; - unsigned HeaderSize = is64Bit() ? sizeof(MachO::mach_header_64) : - sizeof(MachO::mach_header); + unsigned HeaderSize = is64Bit() ? macho::Header64Size : macho::Header32Size; Load.Ptr = getPtr(this, HeaderSize); - Load.C = getStruct<MachO::load_command>(this, Load.Ptr); + Load.C = getStruct<macho::LoadCommand>(this, Load.Ptr); return Load; } MachOObjectFile::LoadCommandInfo MachOObjectFile::getNextLoadCommandInfo(const LoadCommandInfo &L) const { MachOObjectFile::LoadCommandInfo Next; - Next.Ptr = L.Ptr + L.C.cmdsize; - Next.C = getStruct<MachO::load_command>(this, Next.Ptr); + Next.Ptr = L.Ptr + L.C.Size; + Next.C = getStruct<macho::LoadCommand>(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::section_64 MachOObjectFile::getSection64(DataRefImpl DRI) const { - return getStruct<MachO::section_64>(this, Sections[DRI.d.a]); +macho::Section64 MachOObjectFile::getSection64(DataRefImpl DRI) const { + return getStruct<macho::Section64>(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::section_64 MachOObjectFile::getSection64(const LoadCommandInfo &L, - unsigned Index) const { +macho::Section64 MachOObjectFile::getSection64(const LoadCommandInfo &L, + unsigned Index) const { const char *Sec = getSectionPtr(this, L, Index); - return getStruct<MachO::section_64>(this, Sec); + return getStruct<macho::Section64>(this, Sec); } -MachO::nlist +macho::SymbolTableEntry MachOObjectFile::getSymbolTableEntry(DataRefImpl DRI) const { const char *P = reinterpret_cast<const char *>(DRI.p); - return getStruct<MachO::nlist>(this, P); + return getStruct<macho::SymbolTableEntry>(this, P); } -MachO::nlist_64 +macho::Symbol64TableEntry MachOObjectFile::getSymbol64TableEntry(DataRefImpl DRI) const { const char *P = reinterpret_cast<const char *>(DRI.p); - return getStruct<MachO::nlist_64>(this, P); + return getStruct<macho::Symbol64TableEntry>(this, P); } -MachO::linkedit_data_command -MachOObjectFile::getLinkeditDataLoadCommand(const LoadCommandInfo &L) const { - return getStruct<MachO::linkedit_data_command>(this, L.Ptr); +macho::LinkeditDataLoadCommand MachOObjectFile::getLinkeditDataLoadCommand( + const MachOObjectFile::LoadCommandInfo &L) const { + return getStruct<macho::LinkeditDataLoadCommand>(this, L.Ptr); } -MachO::segment_command +macho::SegmentLoadCommand MachOObjectFile::getSegmentLoadCommand(const LoadCommandInfo &L) const { - return getStruct<MachO::segment_command>(this, L.Ptr); + return getStruct<macho::SegmentLoadCommand>(this, L.Ptr); } -MachO::segment_command_64 +macho::Segment64LoadCommand MachOObjectFile::getSegment64LoadCommand(const LoadCommandInfo &L) const { - return getStruct<MachO::segment_command_64>(this, L.Ptr); + return getStruct<macho::Segment64LoadCommand>(this, L.Ptr); } -MachO::linker_options_command +macho::LinkerOptionsLoadCommand MachOObjectFile::getLinkerOptionsLoadCommand(const LoadCommandInfo &L) const { - return getStruct<MachO::linker_options_command>(this, L.Ptr); + return getStruct<macho::LinkerOptionsLoadCommand>(this, L.Ptr); } -MachO::any_relocation_info +macho::RelocationEntry MachOObjectFile::getRelocation(DataRefImpl Rel) const { const char *P = reinterpret_cast<const char *>(Rel.p); - return getStruct<MachO::any_relocation_info>(this, P); + return getStruct<macho::RelocationEntry>(this, P); } -MachO::data_in_code_entry +macho::DataInCodeTableEntry MachOObjectFile::getDice(DataRefImpl Rel) const { const char *P = reinterpret_cast<const char *>(Rel.p); - return getStruct<MachO::data_in_code_entry>(this, P); + return getStruct<macho::DataInCodeTableEntry>(this, P); } -MachO::mach_header MachOObjectFile::getHeader() const { - return getStruct<MachO::mach_header>(this, getPtr(this, 0)); +macho::Header MachOObjectFile::getHeader() const { + return getStruct<macho::Header>(this, getPtr(this, 0)); } -MachO::mach_header_64 MachOObjectFile::getHeader64() const { - return getStruct<MachO::mach_header_64>(this, getPtr(this, 0)); +macho::Header64Ext MachOObjectFile::getHeader64Ext() const { + return + getStruct<macho::Header64Ext>(this, getPtr(this, sizeof(macho::Header))); } -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::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)); } -MachO::data_in_code_entry +macho::DataInCodeTableEntry MachOObjectFile::getDataInCodeTableEntry(uint32_t DataOffset, unsigned Index) const { - uint64_t Offset = DataOffset + Index * sizeof(MachO::data_in_code_entry); - return getStruct<MachO::data_in_code_entry>(this, getPtr(this, Offset)); + uint64_t Offset = DataOffset + Index * sizeof(macho::DataInCodeTableEntry); + return getStruct<macho::DataInCodeTableEntry>(this, getPtr(this, Offset)); } -MachO::symtab_command MachOObjectFile::getSymtabLoadCommand() const { - return getStruct<MachO::symtab_command>(this, SymtabLoadCmd); +macho::SymtabLoadCommand MachOObjectFile::getSymtabLoadCommand() const { + return getStruct<macho::SymtabLoadCommand>(this, SymtabLoadCmd); } -MachO::dysymtab_command MachOObjectFile::getDysymtabLoadCommand() const { - return getStruct<MachO::dysymtab_command>(this, DysymtabLoadCmd); +macho::DysymtabLoadCommand MachOObjectFile::getDysymtabLoadCommand() const { + return getStruct<macho::DysymtabLoadCommand>(this, DysymtabLoadCmd); } -MachO::linkedit_data_command +macho::LinkeditDataLoadCommand MachOObjectFile::getDataInCodeLoadCommand() const { if (DataInCodeLoadCmd) - return getStruct<MachO::linkedit_data_command>(this, DataInCodeLoadCmd); + return getStruct<macho::LinkeditDataLoadCommand>(this, DataInCodeLoadCmd); // If there is no DataInCodeLoadCmd return a load command with zero'ed fields. - 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; + macho::LinkeditDataLoadCommand Cmd; + Cmd.Type = macho::LCT_DataInCode; + Cmd.Size = macho::LinkeditLoadCommandSize; + Cmd.DataOffset = 0; + Cmd.DataSize = 0; return Cmd; } StringRef MachOObjectFile::getStringTableData() const { - MachO::symtab_command S = getSymtabLoadCommand(); - return getData().substr(S.stroff, S.strsize); + macho::SymtabLoadCommand S = getSymtabLoadCommand(); + return getData().substr(S.StringTableOffset, S.StringTableSize); } bool MachOObjectFile::is64Bit() const { diff --git a/lib/Object/MachOUniversal.cpp b/lib/Object/MachOUniversal.cpp index 75160af..b76f10e 100644 --- a/lib/Object/MachOUniversal.cpp +++ b/lib/Object/MachOUniversal.cpp @@ -31,18 +31,18 @@ template<typename T> static void SwapStruct(T &Value); template<> -void SwapStruct(MachO::fat_header &H) { - SwapValue(H.magic); - SwapValue(H.nfat_arch); +void SwapStruct(macho::FatHeader &H) { + SwapValue(H.Magic); + SwapValue(H.NumFatArch); } template<> -void SwapStruct(MachO::fat_arch &H) { - SwapValue(H.cputype); - SwapValue(H.cpusubtype); - SwapValue(H.offset); - SwapValue(H.size); - SwapValue(H.align); +void SwapStruct(macho::FatArchHeader &H) { + SwapValue(H.CPUType); + SwapValue(H.CPUSubtype); + SwapValue(H.Offset); + SwapValue(H.Size); + SwapValue(H.Align); } template<typename T> @@ -63,10 +63,10 @@ MachOUniversalBinary::ObjectForArch::ObjectForArch( } else { // Parse object header. StringRef ParentData = Parent->getData(); - 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) { + const char *HeaderPos = ParentData.begin() + macho::FatHeaderSize + + Index * macho::FatArchHeaderSize; + Header = getUniversalBinaryStruct<macho::FatArchHeader>(HeaderPos); + if (ParentData.size() < Header.Offset + Header.Size) { clear(); } } @@ -76,10 +76,10 @@ error_code MachOUniversalBinary::ObjectForArch::getAsObjectFile( 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)) { @@ -96,31 +96,31 @@ MachOUniversalBinary::MachOUniversalBinary(MemoryBuffer *Source, error_code &ec) : Binary(Binary::ID_MachOUniversalBinary, Source), NumberOfObjects(0) { - if (Source->getBufferSize() < sizeof(MachO::fat_header)) { + if (Source->getBufferSize() < macho::FatHeaderSize) { ec = object_error::invalid_file_type; return; } // Check for magic value and sufficient header size. StringRef Buf = getData(); - 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) { + 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) { ec = object_error::parse_failed; return; } ec = object_error::success; } -static bool getCTMForArch(Triple::ArchType Arch, MachO::CPUType &CTM) { +static bool getCTMForArch(Triple::ArchType Arch, mach::CPUTypeMachine &CTM) { switch (Arch) { - 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; + 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; default: return false; } } @@ -128,7 +128,7 @@ static bool getCTMForArch(Triple::ArchType Arch, MachO::CPUType &CTM) { error_code MachOUniversalBinary::getObjectForArch(Triple::ArchType Arch, OwningPtr<ObjectFile> &Result) const { - MachO::CPUType CTM; + mach::CPUTypeMachine CTM; if (!getCTMForArch(Arch, CTM)) return object_error::arch_not_found; for (object_iterator I = begin_objects(), E = end_objects(); I != E; ++I) { |