[llvm] r189315 - Move everything depending on Object/MachOFormat.h over to Support/MachO.h.
Charles Davis
cdavis5x at gmail.com
Mon Aug 26 22:32:52 PDT 2013
On Aug 26, 2013, at 11:19 PM, David Blaikie wrote:
> On Mon, Aug 26, 2013 at 10:00 PM, Charles Davis <cdavis5x at gmail.com> wrote:
>> Author: cdavis
>> Date: Tue Aug 27 00:00:43 2013
>> New Revision: 189315
>>
>> URL: http://llvm.org/viewvc/llvm-project?rev=189315&view=rev
>> Log:
>> Move everything depending on Object/MachOFormat.h over to Support/MachO.h.
>
> There seem to be a number of unrelated changes in this patch -
> especially for such a large change, please commit the mechanical
> portion separately from any other cleanup/changes.
Sorry. Would you like me to revert this particular change?
>
> rSpecifically, macho-dump.cpp DumpLoadCommand is producing warnings
> (which, since many of us compile with -Werror, is a build break) under
> Clang due to your change. I've cleaned this up (by changing the code
> back to the way it was written previously) in r189319.
Huh. This patch is pretty old: it was written when MachOObject still existed. Since then, lots of changes were made to the affected portions, and I usually make an effort to thoughtfully merge them together, but sometimes I just blindly keep all of my changes--this is, after all, a fairly large patch.
>
>>
>> Removed:
>> llvm/trunk/include/llvm/Object/MachOFormat.h
>> Modified:
>> llvm/trunk/include/llvm/MC/MCMachObjectWriter.h
>> llvm/trunk/include/llvm/Object/MachO.h
>> llvm/trunk/include/llvm/Object/MachOUniversal.h
>> llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
>> llvm/trunk/lib/MC/MCObjectDisassembler.cpp
>> llvm/trunk/lib/MC/MCObjectSymbolizer.cpp
>> llvm/trunk/lib/MC/MachObjectWriter.cpp
>> llvm/trunk/lib/Object/MachOObjectFile.cpp
>> llvm/trunk/lib/Object/MachOUniversal.cpp
>> llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
>> llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp
>> llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp
>> llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp
>> llvm/trunk/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
>> llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp
>> llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp
>> llvm/trunk/tools/llvm-objdump/MachODump.cpp
>> llvm/trunk/tools/llvm-readobj/MachODumper.cpp
>> llvm/trunk/tools/macho-dump/macho-dump.cpp
>>
>> Modified: llvm/trunk/include/llvm/MC/MCMachObjectWriter.h
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCMachObjectWriter.h?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/include/llvm/MC/MCMachObjectWriter.h (original)
>> +++ llvm/trunk/include/llvm/MC/MCMachObjectWriter.h Tue Aug 27 00:00:43 2013
>> @@ -15,8 +15,8 @@
>> #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 {
>> @@ -98,7 +98,7 @@ class MachObjectWriter : public MCObject
>> /// @{
>>
>> llvm::DenseMap<const MCSectionData*,
>> - std::vector<object::macho::RelocationEntry> > Relocations;
>> + std::vector<MachO::any_relocation_info> > Relocations;
>> llvm::DenseMap<const MCSectionData*, unsigned> IndirectSymBase;
>>
>> /// @}
>> @@ -155,9 +155,8 @@ public:
>>
>> 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;
>> }
>>
>> /// @}
>> @@ -213,7 +212,21 @@ public:
>> // these through in many cases.
>>
>> void addRelocation(const MCSectionData *SD,
>> - object::macho::RelocationEntry &MRE) {
>> + MachO::relocation_info &MRE) {
>> + MachO::any_relocation_info AMRE;
>> + memcpy(&AMRE, &MRE, sizeof(MRE));
>> + Relocations[SD].push_back(AMRE);
>> + }
>> +
>> + void addRelocation(const MCSectionData *SD,
>> + MachO::scattered_relocation_info &SMRE) {
>> + MachO::any_relocation_info MRE;
>> + memcpy(&MRE, &SMRE, sizeof(MRE));
>> + Relocations[SD].push_back(MRE);
>> + }
>> +
>> + void addRelocation(const MCSectionData *SD,
>> + MachO::any_relocation_info &MRE) {
>> Relocations[SD].push_back(MRE);
>> }
>>
>>
>> Modified: llvm/trunk/include/llvm/Object/MachO.h
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Object/MachO.h?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/include/llvm/Object/MachO.h (original)
>> +++ llvm/trunk/include/llvm/Object/MachO.h Tue Aug 27 00:00:43 2013
>> @@ -18,8 +18,8 @@
>> #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 {
>> @@ -53,7 +53,7 @@ class MachOObjectFile : public ObjectFil
>> 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,
>> @@ -146,50 +146,53 @@ public:
>> 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::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::LinkeditDataLoadCommand
>> + 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;
>> @@ -223,8 +226,8 @@ inline bool DiceRef::operator<(const Dic
>>
>> 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;
>> @@ -237,24 +240,24 @@ inline error_code DiceRef::getNext(DiceR
>> 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;
>> }
>>
>>
>> Removed: llvm/trunk/include/llvm/Object/MachOFormat.h
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Object/MachOFormat.h?rev=189314&view=auto
>> ==============================================================================
>> --- llvm/trunk/include/llvm/Object/MachOFormat.h (original)
>> +++ llvm/trunk/include/llvm/Object/MachOFormat.h (removed)
>> @@ -1,452 +0,0 @@
>> -//===- 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
>>
>> Modified: llvm/trunk/include/llvm/Object/MachOUniversal.h
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Object/MachOUniversal.h?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/include/llvm/Object/MachOUniversal.h (original)
>> +++ llvm/trunk/include/llvm/Object/MachOUniversal.h Tue Aug 27 00:00:43 2013
>> @@ -18,7 +18,7 @@
>> #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 {
>> @@ -35,7 +35,7 @@ public:
>> /// \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);
>> @@ -50,7 +50,7 @@ public:
>> }
>>
>> 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;
>> };
>>
>> Modified: llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp (original)
>> +++ llvm/trunk/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp Tue Aug 27 00:00:43 2013
>> @@ -180,7 +180,7 @@ bool RuntimeDyldMachO::resolveI386Reloca
>> 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) {
>> @@ -189,9 +189,9 @@ bool RuntimeDyldMachO::resolveI386Reloca
>> }
>> 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!");
>> }
>> }
>> @@ -213,12 +213,12 @@ bool RuntimeDyldMachO::resolveX86_64Relo
>> 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).
>> @@ -229,10 +229,10 @@ bool RuntimeDyldMachO::resolveX86_64Relo
>> }
>> 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!");
>> }
>> }
>> @@ -257,17 +257,17 @@ bool RuntimeDyldMachO::resolveARMRelocat
>> 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;
>> for (unsigned i = 0; i < Size; ++i) {
>> - *p++ = (uint8_t)Value;
>> + *p++ = (uint8_t)(Value & 0xff);
>> Value >>= 8;
>> }
>> 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;
>> @@ -283,14 +283,14 @@ bool RuntimeDyldMachO::resolveARMRelocat
>> *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;
>> @@ -304,7 +304,7 @@ void RuntimeDyldMachO::processRelocation
>> 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);
>>
>> @@ -359,8 +359,8 @@ void RuntimeDyldMachO::processRelocation
>> 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);
>> @@ -371,7 +371,7 @@ void RuntimeDyldMachO::processRelocation
>> 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
>> @@ -380,9 +380,9 @@ void RuntimeDyldMachO::processRelocation
>> 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.
>> @@ -397,7 +397,7 @@ void RuntimeDyldMachO::processRelocation
>> 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
>>
>> Modified: llvm/trunk/lib/MC/MCObjectDisassembler.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCObjectDisassembler.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/MC/MCObjectDisassembler.cpp (original)
>> +++ llvm/trunk/lib/MC/MCObjectDisassembler.cpp Tue Aug 27 00:00:43 2013
>> @@ -537,10 +537,10 @@ uint64_t MCMachOObjectDisassembler::getE
>>
>> // 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;
>>
>> Modified: llvm/trunk/lib/MC/MCObjectSymbolizer.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCObjectSymbolizer.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/MC/MCObjectSymbolizer.cpp (original)
>> +++ llvm/trunk/lib/MC/MCObjectSymbolizer.cpp Tue Aug 27 00:00:43 2013
>> @@ -60,13 +60,13 @@ MCMachObjectSymbolizer(MCContext &Ctx, O
>> 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);
>> @@ -86,9 +86,8 @@ StringRef MCMachObjectSymbolizer::findEx
>> 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();
>>
>> Modified: llvm/trunk/lib/MC/MachObjectWriter.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MachObjectWriter.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/MC/MachObjectWriter.cpp (original)
>> +++ llvm/trunk/lib/MC/MachObjectWriter.cpp Tue Aug 27 00:00:43 2013
>> @@ -20,12 +20,11 @@
>> #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();
>> @@ -128,7 +127,7 @@ void MachObjectWriter::WriteHeader(unsig
>> 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)
>> @@ -136,12 +135,12 @@ void MachObjectWriter::WriteHeader(unsig
>> 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);
>> @@ -149,7 +148,7 @@ void MachObjectWriter::WriteHeader(unsig
>> 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.
>> @@ -167,12 +166,12 @@ void MachObjectWriter::WriteSegmentLoadC
>> (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()) {
>> @@ -240,8 +239,8 @@ void MachObjectWriter::WriteSection(cons
>> 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,
>> @@ -253,14 +252,14 @@ void MachObjectWriter::WriteSymtabLoadCo
>> 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,
>> @@ -276,8 +275,8 @@ void MachObjectWriter::WriteDysymtabLoad
>> 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);
>> @@ -297,7 +296,7 @@ void MachObjectWriter::WriteDysymtabLoad
>> 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,
>> @@ -312,20 +311,20 @@ void MachObjectWriter::WriteNlist(MachSy
>> //
>> // 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()) {
>> @@ -369,17 +368,17 @@ void MachObjectWriter::WriteLinkeditLoad
>> (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);
>> @@ -392,10 +391,10 @@ void MachObjectWriter::WriteLinkerOption
>> 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];
>> @@ -723,14 +722,14 @@ void MachObjectWriter::WriteObject(MCAss
>> // 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.
>> @@ -738,8 +737,8 @@ void MachObjectWriter::WriteObject(MCAss
>> 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.
>> @@ -753,8 +752,8 @@ void MachObjectWriter::WriteObject(MCAss
>>
>> // 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;
>> @@ -791,11 +790,11 @@ void MachObjectWriter::WriteObject(MCAss
>> 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.
>> @@ -803,7 +802,7 @@ void MachObjectWriter::WriteObject(MCAss
>> if (NumDataRegions) {
>> uint64_t DataRegionsOffset = RelocTableEnd;
>> uint64_t DataRegionsSize = NumDataRegions * 8;
>> - WriteLinkeditLoadCommand(macho::LCT_DataInCode, DataRegionsOffset,
>> + WriteLinkeditLoadCommand(MachO::LC_DATA_IN_CODE, DataRegionsOffset,
>> DataRegionsSize);
>> }
>>
>> @@ -830,8 +829,9 @@ void MachObjectWriter::WriteObject(MCAss
>>
>> // 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());
>>
>> @@ -864,10 +864,10 @@ void MachObjectWriter::WriteObject(MCAss
>> 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);
>> }
>> }
>>
>> @@ -906,9 +906,9 @@ void MachObjectWriter::WriteObject(MCAss
>> // 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;
>> }
>>
>> Modified: llvm/trunk/lib/Object/MachOObjectFile.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Object/MachOObjectFile.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Object/MachOObjectFile.cpp (original)
>> +++ llvm/trunk/lib/Object/MachOObjectFile.cpp Tue Aug 27 00:00:43 2013
>> @@ -14,11 +14,9 @@
>>
>> #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>
>> @@ -31,16 +29,16 @@ using namespace object;
>> 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>
>> @@ -52,167 +50,174 @@ 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>
>> @@ -228,11 +233,11 @@ static uint32_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 *
>> @@ -241,23 +246,23 @@ getSectionPtr(const MachOObjectFile *O,
>> 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 reinterpret_cast<const char *>(SectionAddr);
>> }
>>
>> static const char *getPtr(const MachOObjectFile *O, size_t Offset) {
>> 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) {
>> @@ -285,11 +290,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::RelocationEntry &RE,
>> + const MachO::any_relocation_info &RE,
>> raw_string_ostream &fmt) {
>> bool IsScattered = O->isRelocationScattered(RE);
>>
>> @@ -357,59 +362,61 @@ static void printRelocationTargetName(co
>> 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,
>> @@ -417,22 +424,22 @@ MachOObjectFile::MachOObjectFile(MemoryB
>> 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);
>> @@ -450,8 +457,8 @@ MachOObjectFile::MachOObjectFile(MemoryB
>> 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;
>> @@ -460,8 +467,8 @@ error_code MachOObjectFile::getSymbolNex
>> 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;
>> }
>> @@ -469,11 +476,11 @@ error_code MachOObjectFile::getSymbolNam
>> 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;
>> }
>> @@ -481,18 +488,18 @@ error_code MachOObjectFile::getSymbolAdd
>> 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;
>> @@ -506,8 +513,8 @@ error_code MachOObjectFile::getSymbolAli
>> 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;
>> }
>> @@ -520,13 +527,13 @@ error_code MachOObjectFile::getSymbolSiz
>> 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);
>> @@ -544,7 +551,7 @@ error_code MachOObjectFile::getSymbolSiz
>> 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;
>> }
>> @@ -562,8 +569,8 @@ error_code MachOObjectFile::getSymbolSiz
>>
>> 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;
>>
>> @@ -586,17 +593,17 @@ error_code MachOObjectFile::getSymbolTyp
>>
>> 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:
>> @@ -604,7 +611,7 @@ error_code MachOObjectFile::getSymbolNMT
>> 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;
>> @@ -612,10 +619,10 @@ error_code MachOObjectFile::getSymbolNMT
>>
>> 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;
>> @@ -623,7 +630,7 @@ error_code MachOObjectFile::getSymbolFla
>> 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) {
>> @@ -648,8 +655,8 @@ error_code MachOObjectFile::getSymbolFla
>> 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();
>> @@ -684,11 +691,11 @@ MachOObjectFile::getSectionName(DataRefI
>> 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;
>> }
>> @@ -696,11 +703,11 @@ MachOObjectFile::getSectionAddress(DataR
>> 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;
>> @@ -712,13 +719,13 @@ MachOObjectFile::getSectionContents(Data
>> 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);
>> @@ -729,11 +736,11 @@ error_code
>> 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;
>> @@ -743,7 +750,7 @@ MachOObjectFile::getSectionAlignment(Dat
>> 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;
>> }
>>
>> @@ -819,11 +826,11 @@ MachOObjectFile::sectionContainsSymbol(D
>> 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;
>> @@ -836,17 +843,17 @@ MachOObjectFile::getSectionRelEnd(DataRe
>> 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);
>> @@ -855,8 +862,8 @@ MachOObjectFile::getSectionRelEnd(DataRe
>>
>> 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;
>> @@ -869,24 +876,24 @@ MachOObjectFile::getRelocationAddress(Da
>>
>> 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));
>> @@ -894,7 +901,7 @@ MachOObjectFile::getRelocationSymbol(Dat
>>
>> 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;
>> }
>> @@ -995,7 +1002,7 @@ MachOObjectFile::getRelocationTypeName(D
>> 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();
>>
>> @@ -1012,47 +1019,47 @@ MachOObjectFile::getRelocationValueStrin
>> 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;
>> @@ -1065,18 +1072,18 @@ MachOObjectFile::getRelocationValueStrin
>> 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.");
>>
>> @@ -1088,18 +1095,16 @@ MachOObjectFile::getRelocationValueStrin
>> }
>>
>> 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.");
>>
>> @@ -1108,7 +1113,7 @@ MachOObjectFile::getRelocationValueStrin
>> 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";
>> @@ -1119,8 +1124,8 @@ MachOObjectFile::getRelocationValueStrin
>> }
>> } 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;
>> @@ -1133,14 +1138,14 @@ MachOObjectFile::getRelocationValueStrin
>>
>> 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
>> @@ -1149,7 +1154,7 @@ MachOObjectFile::getRelocationValueStrin
>>
>> // 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);
>> }
>> @@ -1181,16 +1186,16 @@ MachOObjectFile::getRelocationHidden(Dat
>> // 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;
>> }
>> }
>> @@ -1213,8 +1218,8 @@ symbol_iterator MachOObjectFile::begin_s
>> 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));
>> }
>>
>> @@ -1223,12 +1228,12 @@ symbol_iterator MachOObjectFile::end_sym
>> 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));
>> }
>> @@ -1323,7 +1328,7 @@ unsigned MachOObjectFile::getArch() cons
>>
>> StringRef MachOObjectFile::getLoadName() const {
>> // TODO: Implement
>> - report_fatal_error("get_load_name() unimplemented in MachOObjectFile");
>> + report_fatal_error("Load name unimplemented in MachOObjectFile");
>> }
>>
>> relocation_iterator MachOObjectFile::getSectionRelBegin(unsigned Index) const {
>> @@ -1343,8 +1348,8 @@ dice_iterator MachOObjectFile::begin_dic
>> 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));
>> }
>>
>> @@ -1353,8 +1358,8 @@ dice_iterator MachOObjectFile::end_dices
>> 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));
>> }
>> @@ -1367,80 +1372,82 @@ MachOObjectFile::getSectionFinalSegmentN
>>
>> 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;
>> @@ -1453,133 +1460,132 @@ MachOObjectFile::LoadCommandInfo
>> 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 {
>>
>> Modified: llvm/trunk/lib/Object/MachOUniversal.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Object/MachOUniversal.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Object/MachOUniversal.cpp (original)
>> +++ llvm/trunk/lib/Object/MachOUniversal.cpp Tue Aug 27 00:00:43 2013
>> @@ -31,18 +31,18 @@ template<typename T>
>> 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>
>> @@ -63,10 +63,10 @@ MachOUniversalBinary::ObjectForArch::Obj
>> } 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();
>> }
>> }
>> @@ -76,10 +76,10 @@ error_code MachOUniversalBinary::ObjectF
>> 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::MachOUniversalBina
>> 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;
>> }
>> }
>> @@ -128,7 +128,7 @@ static bool getCTMForArch(Triple::ArchTy
>> 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) {
>>
>> Modified: llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp (original)
>> +++ llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp Tue Aug 27 00:00:43 2013
>> @@ -25,9 +25,9 @@
>> #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;
>>
>> @@ -640,16 +640,16 @@ public:
>> // 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);
>> }
>>
>> @@ -664,18 +664,18 @@ MCAsmBackend *llvm::createARMAsmBackend(
>> 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);
>> }
>>
>> Modified: llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp (original)
>> +++ llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachObjectWriter.cpp Tue Aug 27 00:00:43 2013
>> @@ -20,10 +20,9 @@
>> #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 {
>> @@ -63,7 +62,7 @@ public:
>>
>> static bool getARMFixupKindMachOInfo(unsigned Kind, unsigned &RelocType,
>> unsigned &Log2Size) {
>> - RelocType = unsigned(macho::RIT_Vanilla);
>> + RelocType = unsigned(MachO::ARM_RELOC_VANILLA);
>> Log2Size = ~0U;
>>
>> switch (Kind) {
>> @@ -92,21 +91,21 @@ static bool getARMFixupKindMachOInfo(uns
>> 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;
>>
>> @@ -121,23 +120,23 @@ static bool getARMFixupKindMachOInfo(uns
>> // 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;
>> }
>> @@ -153,7 +152,7 @@ RecordARMScatteredHalfRelocation(MachObj
>> 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();
>> @@ -179,7 +178,7 @@ RecordARMScatteredHalfRelocation(MachObj
>> "' 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());
>> }
>> @@ -223,29 +222,28 @@ RecordARMScatteredHalfRelocation(MachObj
>> break;
>> }
>>
>> - if (Type == macho::RIT_ARM_HalfDifference) {
>> + MachO::scattered_relocation_info MRE;
>> + 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;
>> + MRE.r_address = OtherHalf;
>> + MRE.r_type = MachO::ARM_RELOC_PAIR;
>> + MRE.r_length = ((MovtBit << 0) |
>> + (ThumbBit << 1));
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_scattered = 1;
>> + MRE.r_value = 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;
>> + MRE.r_address = FixupOffset;
>> + MRE.r_type = Type;
>> + MRE.r_length = ((MovtBit << 0) |
>> + (ThumbBit << 1));
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_scattered = 1;
>> + MRE.r_value = Value;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> }
>>
>> @@ -259,7 +257,7 @@ void ARMMachObjectWriter::RecordARMScatt
>> 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();
>> @@ -284,31 +282,30 @@ void ARMMachObjectWriter::RecordARMScatt
>> "' 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());
>> }
>>
>> + MachO::scattered_relocation_info MRE;
>> // 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) {
>> + MRE.r_address = 0;
>> + MRE.r_type = MachO::ARM_RELOC_PAIR;
>> + MRE.r_length = Log2Size;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_scattered = 1;
>> + MRE.r_value = 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;
>> + MRE.r_address = FixupOffset;
>> + MRE.r_type = Type;
>> + MRE.r_length = Log2Size;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_scattered = 1;
>> + MRE.r_value = Value;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> }
>>
>> @@ -326,13 +323,13 @@ bool ARMMachObjectWriter::requiresExtern
>> 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.
>> @@ -361,7 +358,7 @@ void ARMMachObjectWriter::RecordRelocati
>> 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
>> @@ -374,7 +371,7 @@ void ARMMachObjectWriter::RecordRelocati
>> // 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,
>> @@ -392,7 +389,7 @@ void ARMMachObjectWriter::RecordRelocati
>> //
>> // 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,
>> @@ -445,17 +442,17 @@ void ARMMachObjectWriter::RecordRelocati
>> }
>>
>> // struct relocation_info (8 bytes)
>> - macho::RelocationEntry MRE;
>> - MRE.Word0 = FixupOffset;
>> - MRE.Word1 = ((Index << 0) |
>> - (IsPCRel << 24) |
>> - (Log2Size << 25) |
>> - (IsExtern << 27) |
>> - (Type << 28));
>> + MachO::relocation_info MRE;
>> + MRE.r_address = FixupOffset;
>> + MRE.r_symbolnum = Index;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_length = Log2Size;
>> + MRE.r_extern = IsExtern;
>> + MRE.r_type = Type;
>>
>> // 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;
>> @@ -474,11 +471,12 @@ void ARMMachObjectWriter::RecordRelocati
>> Value = FixedValue & 0xffff;
>> break;
>> }
>> - macho::RelocationEntry MREPair;
>> - MREPair.Word0 = Value;
>> - MREPair.Word1 = ((0xffffff) |
>> - (Log2Size << 25) |
>> - (macho::RIT_Pair << 28));
>> + MachO::relocation_info MREPair;
>> + MREPair.r_address = Value;
>> + MREPair.r_symbolnum = 0xffffff;
>> + MREPair.r_length = Log2Size;
>> + MREPair.r_pcrel = MREPair.r_extern = 0;
>> + MREPair.r_type = MachO::ARM_RELOC_PAIR;
>>
>> Writer->addRelocation(Fragment->getParent(), MREPair);
>> }
>>
>> Modified: llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp (original)
>> +++ llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp Tue Aug 27 00:00:43 2013
>> @@ -16,9 +16,9 @@
>> #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;
>>
>> @@ -164,8 +164,8 @@ namespace {
>> 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 {
>>
>> Modified: llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp (original)
>> +++ llvm/trunk/lib/Target/PowerPC/MCTargetDesc/PPCMachObjectWriter.cpp Tue Aug 27 00:00:43 2013
>> @@ -16,12 +16,11 @@
>> #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 {
>> @@ -90,29 +89,29 @@ static unsigned getRelocType(const MCVal
>> 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;
>> @@ -126,13 +125,13 @@ static unsigned getRelocType(const MCVal
>> 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;
>> @@ -145,30 +144,34 @@ static unsigned getRelocType(const MCVal
>> 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) {
>> - // 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;
>> +makeScatteredRelocationInfo(MachO::scattered_relocation_info &MRE,
>> + const uint32_t Addr, const unsigned Type,
>> + const unsigned Log2Size, const unsigned IsPCRel,
>> + const uint32_t Value2) {
>> + MRE.r_scattered = true;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_length = Log2Size;
>> + MRE.r_type = Type;
>> + MRE.r_address = Addr;
>> + MRE.r_value = Value2;
>> }
>>
>> /// Compute fixup offset (address).
>> @@ -223,18 +226,19 @@ bool PPCMachObjectWriter::RecordScattere
>> 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.
>> @@ -253,7 +257,7 @@ bool PPCMachObjectWriter::RecordScattere
>> // 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.
>> @@ -262,12 +266,12 @@ bool PPCMachObjectWriter::RecordScattere
>> // 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;
>> @@ -276,9 +280,9 @@ bool PPCMachObjectWriter::RecordScattere
>> break;
>> }
>>
>> - macho::RelocationEntry MRE;
>> - makeScatteredRelocationInfo(MRE, other_half, macho::RIT_Pair, Log2Size,
>> - IsPCRel, Value2);
>> + MachO::scattered_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
>> @@ -291,7 +295,7 @@ bool PPCMachObjectWriter::RecordScattere
>> if (FixupOffset > 0xffffff)
>> return false;
>> }
>> - macho::RelocationEntry MRE;
>> + MachO::scattered_relocation_info MRE;
>> makeScatteredRelocationInfo(MRE, FixupOffset, Type, Log2Size, IsPCRel, Value);
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> return true;
>> @@ -312,7 +316,8 @@ void PPCMachObjectWriter::RecordPPCReloc
>> // 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;
>> @@ -369,8 +374,7 @@ void PPCMachObjectWriter::RecordPPCReloc
>> FixedValue -= Writer->getSectionAddress(Fragment->getParent());
>> }
>>
>> - // 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);
>>
>> Modified: llvm/trunk/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp (original)
>> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp Tue Aug 27 00:00:43 2013
>> @@ -19,10 +19,10 @@
>> #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;
>> @@ -395,8 +395,8 @@ public:
>>
>> 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);
>> }
>> };
>>
>> @@ -409,8 +409,8 @@ public:
>>
>> 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 {
>>
>> Modified: llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp (original)
>> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp Tue Aug 27 00:00:43 2013
>> @@ -17,7 +17,7 @@
>>
>> using namespace llvm;
>> using namespace object;
>> -using namespace macho;
>> +using namespace MachO;
>>
>> namespace {
>> class X86_64MachORelocationInfo : public MCRelocationInfo {
>> @@ -33,7 +33,7 @@ public:
>> 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);
>> @@ -43,44 +43,44 @@ public:
>> 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.");
>>
>>
>> Modified: llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp (original)
>> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachObjectWriter.cpp Tue Aug 27 00:00:43 2013
>> @@ -16,12 +16,11 @@
>> #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 {
>> @@ -132,7 +131,7 @@ void X86MachObjectWriter::RecordX86_64Re
>>
>> 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
>> @@ -141,7 +140,7 @@ void X86MachObjectWriter::RecordX86_64Re
>> // 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();
>> @@ -193,15 +192,15 @@ void X86MachObjectWriter::RecordX86_64Re
>> Index = A_SD.getFragment()->getParent()->getOrdinal() + 1;
>> IsExtern = 0;
>> }
>> - Type = macho::RIT_X86_64_Unsigned;
>> + Type = MachO::X86_64_RELOC_UNSIGNED;
>>
>> - macho::RelocationEntry MRE;
>> - MRE.Word0 = FixupOffset;
>> - MRE.Word1 = ((Index << 0) |
>> - (IsPCRel << 24) |
>> - (Log2Size << 25) |
>> - (IsExtern << 27) |
>> - (Type << 28));
>> + MachO::relocation_info MRE;
>> + MRE.r_address = FixupOffset;
>> + MRE.r_symbolnum = Index;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_length = Log2Size;
>> + MRE.r_extern = IsExtern;
>> + MRE.r_type = Type;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>>
>> if (B_Base) {
>> @@ -212,7 +211,7 @@ void X86MachObjectWriter::RecordX86_64Re
>> 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);
>> @@ -272,15 +271,15 @@ void X86MachObjectWriter::RecordX86_64Re
>> // 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
>> @@ -297,9 +296,9 @@ void X86MachObjectWriter::RecordX86_64Re
>> // (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 {
>> @@ -307,24 +306,24 @@ void X86MachObjectWriter::RecordX86_64Re
>> 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;
>> }
>> }
>>
>> @@ -332,13 +331,13 @@ void X86MachObjectWriter::RecordX86_64Re
>> 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::relocation_info MRE;
>> + MRE.r_address = FixupOffset;
>> + MRE.r_symbolnum = Index;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_length = Log2Size;
>> + MRE.r_extern = IsExtern;
>> + MRE.r_type = Type;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> }
>>
>> @@ -352,7 +351,7 @@ bool X86MachObjectWriter::RecordScattere
>> 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();
>> @@ -379,15 +378,16 @@ bool X86MachObjectWriter::RecordScattere
>> // 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());
>> }
>>
>> + MachO::scattered_relocation_info MRE;
>> // 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) {
>> @@ -401,13 +401,12 @@ bool X86MachObjectWriter::RecordScattere
>> 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;
>> + MRE.r_address = 0;
>> + MRE.r_type = MachO::GENERIC_RELOC_PAIR;
>> + MRE.r_length = Log2Size;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_scattered = 1;
>> + MRE.r_value = Value2;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> } else {
>> // If the offset is more than 24-bits, it won't fit in a scattered
>> @@ -421,13 +420,12 @@ bool X86MachObjectWriter::RecordScattere
>> return false;
>> }
>>
>> - macho::RelocationEntry MRE;
>> - MRE.Word0 = ((FixupOffset << 0) |
>> - (Type << 24) |
>> - (Log2Size << 28) |
>> - (IsPCRel << 30) |
>> - macho::RF_Scattered);
>> - MRE.Word1 = Value;
>> + MRE.r_address = FixupOffset;
>> + MRE.r_type = Type;
>> + MRE.r_length = Log2Size;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_scattered = 1;
>> + MRE.r_value = Value;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> return true;
>> }
>> @@ -469,13 +467,13 @@ void X86MachObjectWriter::RecordTLVPRelo
>> }
>>
>> // 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::relocation_info MRE;
>> + MRE.r_address = Value;
>> + MRE.r_symbolnum = Index;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_length = Log2Size;
>> + MRE.r_extern = 1;
>> + MRE.r_type = MachO::GENERIC_RELOC_TLV;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> }
>>
>> @@ -535,7 +533,7 @@ void X86MachObjectWriter::RecordX86Reloc
>> //
>> // 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()) {
>> @@ -566,17 +564,17 @@ void X86MachObjectWriter::RecordX86Reloc
>> 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::relocation_info MRE;
>> + MRE.r_address = FixupOffset;
>> + MRE.r_symbolnum = Index;
>> + MRE.r_pcrel = IsPCRel;
>> + MRE.r_length = Log2Size;
>> + MRE.r_extern = IsExtern;
>> + MRE.r_type = Type;
>> Writer->addRelocation(Fragment->getParent(), MRE);
>> }
>>
>>
>> Modified: llvm/trunk/tools/llvm-objdump/MachODump.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-objdump/MachODump.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/tools/llvm-objdump/MachODump.cpp (original)
>> +++ llvm/trunk/tools/llvm-objdump/MachODump.cpp Tue Aug 27 00:00:43 2013
>> @@ -104,7 +104,7 @@ static void DumpDataInCode(const char *b
>> uint64_t Value;
>>
>> switch (Kind) {
>> - case macho::Data:
>> + case MachO::DICE_KIND_DATA:
>> switch (Size) {
>> case 4:
>> Value = bytes[3] << 24 |
>> @@ -125,16 +125,16 @@ static void DumpDataInCode(const char *b
>> }
>> 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 |
>> @@ -148,7 +148,7 @@ static void DumpDataInCode(const char *b
>> }
>>
>> static void
>> -getSectionsAndSymbols(const macho::Header Header,
>> +getSectionsAndSymbols(const MachO::mach_header Header,
>> MachOObjectFile *MachOObj,
>> std::vector<SectionRef> &Sections,
>> std::vector<SymbolRef> &Symbols,
>> @@ -171,25 +171,26 @@ getSectionsAndSymbols(const macho::Heade
>> 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 ||
>> + Command.C.cmd == MachO::LC_SEGMENT_64) {
>> + 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);
>> @@ -244,7 +245,7 @@ static void DisassembleInputMachO2(Strin
>>
>> 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.
>> @@ -267,7 +268,7 @@ static void DisassembleInputMachO2(Strin
>>
>> // 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;
>>
>> Modified: llvm/trunk/tools/llvm-readobj/MachODumper.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-readobj/MachODumper.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/tools/llvm-readobj/MachODumper.cpp (original)
>> +++ llvm/trunk/tools/llvm-readobj/MachODumper.cpp Tue Aug 27 00:00:43 2013
>> @@ -166,28 +166,28 @@ static void getSection(const MachOObject
>> 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;
>> }
>>
>>
>> @@ -195,20 +195,20 @@ static void getSymbol(const MachOObjectF
>> 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() {
>> @@ -349,7 +349,7 @@ void MachODumper::printRelocation(const
>> 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) {
>>
>> Modified: llvm/trunk/tools/macho-dump/macho-dump.cpp
>> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/macho-dump/macho-dump.cpp?rev=189315&r1=189314&r2=189315&view=diff
>> ==============================================================================
>> --- llvm/trunk/tools/macho-dump/macho-dump.cpp (original)
>> +++ llvm/trunk/tools/macho-dump/macho-dump.cpp Tue Aug 27 00:00:43 2013
>> @@ -99,10 +99,10 @@ static int DumpSectionData(const MachOOb
>> 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";
>>
>> @@ -124,23 +124,21 @@ static int DumpSectionData(const MachOOb
>>
>> 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";
>>
>> @@ -149,24 +147,22 @@ static int DumpSegmentCommand(const Mach
>>
>> 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);
>> + for (unsigned i = 0; i != SLC.nsects; ++i) {
>> + MachO::section_64 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);
>> + 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";
>>
>> @@ -190,12 +186,12 @@ static void DumpSymbolTableEntryData(con
>> }
>>
>> 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', '";
>> @@ -211,14 +207,14 @@ static int DumpSymtabCommand(const MachO
>> 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);
>> }
>> }
>> @@ -228,37 +224,33 @@ static int DumpSymtabCommand(const MachO
>> }
>>
>> static int DumpDysymtabCommand(const MachOObjectFile &Obj) {
>> - macho::DysymtabLoadCommand DLC = Obj.getDysymtabLoadCommand();
>> + MachO::dysymtab_command 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";
>> + 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";
>>
>> @@ -268,13 +260,13 @@ static int DumpDysymtabCommand(const Mac
>> 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";
>> @@ -287,19 +279,18 @@ DumpLinkeditDataCommand(const MachOObjec
>> 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";
>> @@ -310,74 +301,84 @@ DumpDataInCodeDataCommand(const MachOObj
>> 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:
>> - return DumpSegmentCommand(Obj, LCI);
>> - case macho::LCT_Segment64:
>> - return DumpSegment64Command(Obj, LCI);
>> - case macho::LCT_Symtab:
>> - return DumpSymtabCommand(Obj);
>> - case macho::LCT_Dysymtab:
>> - return DumpDysymtabCommand(Obj);
>> - case macho::LCT_CodeSignature:
>> - case macho::LCT_SegmentSplitInfo:
>> - case macho::LCT_FunctionStarts:
>> - return DumpLinkeditDataCommand(Obj, LCI);
>> - case macho::LCT_DataInCode:
>> - return DumpDataInCodeDataCommand(Obj, LCI);
>> - case macho::LCT_LinkerOptions:
>> - return DumpLinkerOptionsCommand(Obj, LCI);
>> + int Res;
>> + switch (LCI.C.cmd) {
>> + case MachO::LC_SEGMENT:
>> + Res = DumpSegmentCommand(Obj, LCI);
>> + break;
>> + case MachO::LC_SEGMENT_64:
>> + Res = DumpSegment64Command(Obj, LCI);
>> + break;
>> + case MachO::LC_SYMTAB:
>> + Res = DumpSymtabCommand(Obj);
>> + break;
>> + case MachO::LC_DYSYMTAB:
>> + Res = DumpDysymtabCommand(Obj);
>> + break;
>> + case MachO::LC_CODE_SIGNATURE:
>> + case MachO::LC_SEGMENT_SPLIT_INFO:
>> + case MachO::LC_FUNCTION_STARTS:
>> + Res = DumpLinkeditDataCommand(Obj, LCI);
>> + break;
>> + case MachO::LC_DATA_IN_CODE:
>> + Res = DumpDataInCodeDataCommand(Obj, LCI);
>> + break;
>> + case MachO::LC_LINKER_OPTIONS:
>> + Res = DumpLinkerOptionsCommand(Obj, LCI);
>> + break;
>> default:
>> - Warning("unknown load command: " + Twine(LCI.C.Type));
>> - return 0;
>> + Warning("unknown load command: " + Twine(LCI.C.cmd));
>> + break;
>> }
>> + return Res;
>> }
>>
>>
>> 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";
>> }
>> }
>>
>> @@ -396,8 +397,13 @@ int main(int argc, char **argv) {
>> 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;
>> @@ -408,7 +414,7 @@ int main(int argc, char **argv) {
>> if (DumpLoadCommand(*InputObject, i, Command))
>> break;
>>
>> - if (i == Header.NumLoadCommands - 1)
>> + if (i == Header->ncmds - 1)
>> break;
>> Command = InputObject->getNextLoadCommandInfo(Command);
>> }
>>
>>
>> _______________________________________________
>> llvm-commits mailing list
>> llvm-commits at cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list