Why Gemfury?
Push, build, and install
RubyGems
npm packages
Python packages
Maven artifacts
PHP packages
Go Modules
Debian packages
RPM packages
NuGet packages
Repository URL to install this package:
|
Version:
3.2.0 ▾
|
unit macho;
{
* Copyright (c) 1999-2008 Apple Inc. All Rights Reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
}
{ converted by Dmitry Boyarintsev 2009 }
{$i fpcdefs.inc}
{$H+}
interface
{$IFDEF FPC}
{$PACKRECORDS C}
{$PACKENUM 4}
{$ENDIF}
// mach/$arch/machine.h
// $arch can be: i386, x86_64, ppc, arm
// currently used is i386
type
integer_t = Integer;
uint8_t = Byte;
int16_t = SmallInt;
uint16_t = Word;
uint32_t = LongWord;
int32_t = Integer;
uint64_t = QWord;
// mach/thread_status.h
{$ifdef i386}
{$endif i386}
// mach/machine.h
type
cpu_type_t = integer_t;
cpu_subtype_t = integer_t;
cpu_threadtype_t = integer_t;
const
CPU_STATE_MAX = 4;
CPU_STATE_USER = 0;
CPU_STATE_SYSTEM = 1;
CPU_STATE_IDLE = 2;
CPU_STATE_NICE = 3;
{* Capability bits used in the definition of cpu_type. }
CPU_ARCH_MASK = $ff000000; { mask for architecture bits }
CPU_ARCH_ABI64 = $01000000; { 64 bit ABI }
{ Machine types known by all. }
CPU_TYPE_ANY = -1;
CPU_TYPE_VAX = 1;
CPU_TYPE_MC680x0 = 6;
CPU_TYPE_X86 = 7;
CPU_TYPE_I386 = CPU_TYPE_X86; { compatibility }
CPU_TYPE_X86_64 = CPU_TYPE_X86 or CPU_ARCH_ABI64;
// skip CPU_TYPE_MIPS = 8;
CPU_TYPE_MC98000 = 10;
CPU_TYPE_HPPA = 11;
CPU_TYPE_ARM = 12;
CPU_TYPE_ARM64 = CPU_TYPE_ARM or CPU_ARCH_ABI64;
CPU_TYPE_MC88000 = 13;
CPU_TYPE_SPARC = 14;
CPU_TYPE_I860 = 15;
// skip CPU_TYPE_ALPHA = 16; */
CPU_TYPE_POWERPC = 18;
CPU_TYPE_POWERPC64 = CPU_TYPE_POWERPC or CPU_ARCH_ABI64;
{*
* Machine subtypes (these are defined here, instead of in a machine
* dependent directory, so that any program can get all definitions
* regardless of where is it compiled).
*}
{*
* Capability bits used in the definition of cpu_subtype.
*}
CPU_SUBTYPE_MASK = $ff000000; { mask for feature flags }
CPU_SUBTYPE_LIB64 = $80000000; { 64 bit libraries }
{*
* Object files that are hand-crafted to run on any
* implementation of an architecture are tagged with
* CPU_SUBTYPE_MULTIPLE. This functions essentially the same as
* the "ALL" subtype of an architecture except that it allows us
* to easily find object files that may need to be modified
* whenever a new implementation of an architecture comes out.
*
* It is the responsibility of the implementor to make sure the
* software handles unsupported implementations elegantly.
*}
CPU_SUBTYPE_MULTIPLE = -1;
CPU_SUBTYPE_LITTLE_ENDIAN = 0;
CPU_SUBTYPE_BIG_ENDIAN = 1;
{*
* Machine threadtypes.
* This is none - not defined - for most machine types/subtypes.
*}
CPU_THREADTYPE_NONE = 0;
{*
* VAX subtypes (these do *not* necessary conform to the actual cpu
* ID assigned by DEC available via the SID register).
*}
CPU_SUBTYPE_VAX_ALL = 0;
CPU_SUBTYPE_VAX780 = 1;
CPU_SUBTYPE_VAX785 = 2;
CPU_SUBTYPE_VAX750 = 3;
CPU_SUBTYPE_VAX730 = 4;
CPU_SUBTYPE_UVAXI = 5;
CPU_SUBTYPE_UVAXII = 6;
CPU_SUBTYPE_VAX8200 = 7;
CPU_SUBTYPE_VAX8500 = 8;
CPU_SUBTYPE_VAX8600 = 9;
CPU_SUBTYPE_VAX8650 = 10;
CPU_SUBTYPE_VAX8800 = 11;
CPU_SUBTYPE_UVAXIII = 12;
{*
* 680x0 subtypes
*
* The subtype definitions here are unusual for historical reasons.
* NeXT used to consider 68030 code as generic 68000 code. For
* backwards compatability:
*
* CPU_SUBTYPE_MC68030 symbol has been preserved for source code
* compatability.
*
* CPU_SUBTYPE_MC680x0_ALL has been defined to be the same
* subtype as CPU_SUBTYPE_MC68030 for binary comatability.
*
* CPU_SUBTYPE_MC68030_ONLY has been added to allow new object
* files to be tagged as containing 68030-specific instructions.
*}
CPU_SUBTYPE_MC680x0_ALL = 1;
CPU_SUBTYPE_MC68030 = 1; { compat }
CPU_SUBTYPE_MC68040 = 2;
CPU_SUBTYPE_MC68030_ONLY = 3;
{* I386 subtypes *}
CPU_SUBTYPE_I386_ALL = 3 + (0 shl 4);
CPU_SUBTYPE_386 = 3 + (0 shl 4);
CPU_SUBTYPE_486 = 4 + (0 shl 4);
CPU_SUBTYPE_486SX = 4 + (8 shl 4); // 8 << 4 = 128
CPU_SUBTYPE_586 = 5 + (0 shl 4);
CPU_SUBTYPE_PENT = 5 + (0 shl 4);
CPU_SUBTYPE_PENTPRO = 6 + (1 shl 4);
CPU_SUBTYPE_PENTII_M3 = 6 + (3 shl 4);
CPU_SUBTYPE_PENTII_M5 = 6 + (5 shl 4);
CPU_SUBTYPE_CELERON = 7 + (6 shl 4);
CPU_SUBTYPE_CELERON_MOBILE = 7 + (7 shl 4);
CPU_SUBTYPE_PENTIUM_3 = 8 + (0 shl 4);
CPU_SUBTYPE_PENTIUM_3_M = 8 + (1 shl 4);
CPU_SUBTYPE_PENTIUM_3_XEON = 8 + (2 shl 4);
CPU_SUBTYPE_PENTIUM_M = 9 + (0 shl 4);
CPU_SUBTYPE_PENTIUM_4 = 10 + (0 shl 4);
CPU_SUBTYPE_PENTIUM_4_M = 10 + (1 shl 4);
CPU_SUBTYPE_ITANIUM = 11 + (0 shl 4);
CPU_SUBTYPE_ITANIUM_2 = 11 + (1 shl 4);
CPU_SUBTYPE_XEON = 12 + (0 shl 4);
CPU_SUBTYPE_XEON_MP = 12 + (1 shl 4);
CPU_SUBTYPE_INTEL_FAMILY_MAX = 15;
CPU_SUBTYPE_INTEL_MODEL_ALL = 0;
{* X86 subtypes. *}
CPU_SUBTYPE_X86_ALL = 3;
CPU_SUBTYPE_X86_64_ALL = 3;
CPU_SUBTYPE_X86_ARCH1 = 4;
CPU_THREADTYPE_INTEL_HTT = 1;
{* Mips subtypes. *}
CPU_SUBTYPE_MIPS_ALL = 0;
CPU_SUBTYPE_MIPS_R2300 = 1;
CPU_SUBTYPE_MIPS_R2600 = 2;
CPU_SUBTYPE_MIPS_R2800 = 3;
CPU_SUBTYPE_MIPS_R2000a = 4; {* pmax *}
CPU_SUBTYPE_MIPS_R2000 = 5;
CPU_SUBTYPE_MIPS_R3000a = 6; { 3max *}
CPU_SUBTYPE_MIPS_R3000 = 7;
{* MC98000 (PowerPC) subtypes *}
CPU_SUBTYPE_MC98000_ALL = 0;
CPU_SUBTYPE_MC98601 = 1;
{*
* HPPA subtypes for Hewlett-Packard HP-PA family of
* risc processors. Port by NeXT to 700 series.
*}
CPU_SUBTYPE_HPPA_ALL = 0;
CPU_SUBTYPE_HPPA_7100 = 0; {* compat *}
CPU_SUBTYPE_HPPA_7100LC = 1;
{* MC88000 subtypes. *}
CPU_SUBTYPE_MC88000_ALL = 0;
CPU_SUBTYPE_MC88100 = 1;
CPU_SUBTYPE_MC88110 = 2;
{* SPARC subtypes *}
CPU_SUBTYPE_SPARC_ALL = 0;
{* I860 subtypes *}
CPU_SUBTYPE_I860_ALL = 0;
CPU_SUBTYPE_I860_860 = 1;
{* PowerPC subtypes *}
CPU_SUBTYPE_POWERPC_ALL = 0;
CPU_SUBTYPE_POWERPC_601 = 1;
CPU_SUBTYPE_POWERPC_602 = 2;
CPU_SUBTYPE_POWERPC_603 = 3;
CPU_SUBTYPE_POWERPC_603e = 4;
CPU_SUBTYPE_POWERPC_603ev = 5;
CPU_SUBTYPE_POWERPC_604 = 6;
CPU_SUBTYPE_POWERPC_604e = 7;
CPU_SUBTYPE_POWERPC_620 = 8;
CPU_SUBTYPE_POWERPC_750 = 9;
CPU_SUBTYPE_POWERPC_7400 = 10;
CPU_SUBTYPE_POWERPC_7450 = 11;
CPU_SUBTYPE_POWERPC_970 = 100;
{* ARM subtypes *}
CPU_SUBTYPE_ARM_ALL = 0;
CPU_SUBTYPE_ARM_V4T = 5;
CPU_SUBTYPE_ARM_V6 = 6;
CPU_SUBTYPE_ARM_V5TEJ = 7;
CPU_SUBTYPE_ARM_XSCALE = 8;
{*
* CPU families (sysctl hw.cpufamily)
*
* These are meant to identify the CPU's marketing name - an
* application can map these to (possibly) localized strings.
* NB: the encodings of the CPU families are intentionally arbitrary.
* There is no ordering, and you should never try to deduce whether
* or not some feature is available based on the family.
* Use feature flags (eg, hw.optional.altivec) to test for optional
* functionality.
*}
CPUFAMILY_UNKNOWN = 0;
CPUFAMILY_POWERPC_G3 = $cee41549;
CPUFAMILY_POWERPC_G4 = $77c184ae;
CPUFAMILY_POWERPC_G5 = $ed76d8aa;
CPUFAMILY_INTEL_6_13 = $aa33392b;
CPUFAMILY_INTEL_6_14 = $73d67300; { "Intel Core Solo" and "Intel Core Duo" (32-bit Pentium-M with SSE3) }
CPUFAMILY_INTEL_6_15 = $426f69ef; { "Intel Core 2 Duo" }
CPUFAMILY_INTEL_6_23 = $78ea4fbc; { Penryn }
CPUFAMILY_INTEL_6_26 = $6b5a4cd2; { Nehalem }
CPUFAMILY_ARM_9 = $e73283ae;
CPUFAMILY_ARM_11 = $8ff620d8;
CPUFAMILY_ARM_XSCALE = $53b005f5;
CPUFAMILY_INTEL_YONAH = CPUFAMILY_INTEL_6_14;
CPUFAMILY_INTEL_MEROM = CPUFAMILY_INTEL_6_15;
CPUFAMILY_INTEL_PENRYN = CPUFAMILY_INTEL_6_23;
CPUFAMILY_INTEL_NEHALEM = CPUFAMILY_INTEL_6_26;
CPUFAMILY_INTEL_CORE = CPUFAMILY_INTEL_6_14;
CPUFAMILY_INTEL_CORE2 = CPUFAMILY_INTEL_6_15;
// mach/vm_prot.h
type
vm_prot_t = Integer;
const
VM_PROT_NONE = $00;
VM_PROT_READ = $01; {* read permission *}
VM_PROT_WRITE = $02; {* write permission *}
VM_PROT_EXECUTE = $04; {* execute permission *}
{*
* The default protection for newly-created virtual memory
*}
VM_PROT_DEFAULT = VM_PROT_READ or VM_PROT_WRITE;
{*
* The maximum privileges possible, for parameter checking.
*}
VM_PROT_ALL = VM_PROT_READ or VM_PROT_WRITE or VM_PROT_EXECUTE;
{*
* An invalid protection value.
* Used only by memory_object_lock_request to indicate no change
* to page locks. Using -1 here is a bad idea because it
* looks like VM_PROT_ALL and then some.
*}
VM_PROT_NO_CHANGE = $08;
{*
* When a caller finds that he cannot obtain write permission on a
* mapped entry, the following flag can be used. The entry will
* be made "needs copy" effectively copying the object (using COW),
* and write permission will be added to the maximum protections
* for the associated entry.
*}
VM_PROT_COPY = $10;
{*
* Another invalid protection value.
* Used only by memory_object_data_request upon an object
* which has specified a copy_call copy strategy. It is used
* when the kernel wants a page belonging to a copy of the
* object, and is only asking the object as a result of
* following a shadow chain. This solves the race between pages
* being pushed up by the memory manager and the kernel
* walking down the shadow chain.
*}
VM_PROT_WANTS_COPY = $10;
{ Constant for the magic field of the mach_header (32-bit architectures) the mach magic number }
const
MH_MAGIC = $feedface;
MH_CIGAM = $cefaedfe; { NXSwapInt(MH_MAGIC) }
type
{ * The 32-bit mach header appears at the very beginning of the object file for 32-bit architectures. }
mach_header = record
magic : uint32_t; { mach magic number identifier }
cputype : cpu_type_t; { cpu specifier }
cpusubtype : cpu_subtype_t; { machine specifier }
filetype : uint32_t; { type of file }
ncmds : uint32_t; { number of load commands }
sizeofcmds : uint32_t; { the size of all the load commands }
flags : uint32_t; { flags }
end;
pmach_header = ^mach_header;
type
{* The 64-bit mach header appears at the very beginning of object files for
* 64-bit architectures. }
mach_header_64 = record
magic : uint32_t; { mach magic number identifier }
cputype : cpu_type_t; { cpu specifier }
cpusubtype : cpu_subtype_t; { machine specifier }
filetype : uint32_t; { type of file }
ncmds : uint32_t; { number of load commands }
sizeofcmds : uint32_t; { the size of all the load commands }
flags : uint32_t; { flags }
reserved : uint32_t; { reserved }
end;
pmach_header_64 = ^mach_header_64;
{ Constant for the magic field of the mach_header_64 (64-bit architectures) }
{ the 64-bit mach magic number }
const
MH_MAGIC_64 = $feedfacf;
MH_CIGAM_64 = $cffaedfe; { NXSwapInt(MH_MAGIC_64) }
{* The layout of the file depends on the filetype. For all but the MH_OBJECT
* file type the segments are padded out and aligned on a segment alignment
* boundary for efficient demand pageing. The MH_EXECUTE, MH_FVMLIB, MH_DYLIB,
* MH_DYLINKER and MH_BUNDLE file types also have the headers included as part
* of their first segment.
*
* The file type MH_OBJECT is a compact format intended as output of the
* assembler and input (and possibly output) of the link editor (the .o
* format). All sections are in one unnamed segment with no segment padding.
* This format is used as an executable format when the file is so small the
* segment padding greatly increases its size.
*
* The file type MH_PRELOAD is an executable format intended for things that
* are not executed under the kernel (proms, stand alones, kernels, etc). The
* format can be executed under the kernel but may demand paged it and not
* preload it before execution.
*
* A core file is in MH_CORE format and can be any in an arbritray legal
* Mach-O file.
*
* Constants for the filetype field of the mach_header }
const
MH_OBJECT = $1; { relocatable object file }
MH_EXECUTE = $2; { demand paged executable file }
MH_FVMLIB = $3; { fixed VM shared library file }
MH_CORE = $4; { core file }
MH_PRELOAD = $5; { preloaded executable file }
MH_DYLIB = $6; { dynamically bound shared library }
MH_DYLINKER = $7; { dynamic link editor }
MH_BUNDLE = $8; { dynamically bound bundle file }
MH_DYLIB_STUB = $9; { shared library stub for static }
MH_DSYM = $a; { linking only, no section contents }
{ companion file with only debug sections }
const
{ Constants for the flags field of the mach_header }
MH_NOUNDEFS = $1; { the object file has no undefined references }
MH_INCRLINK = $2; { the object file is the output of an incremental link against a base file and can't be link edited again }
MH_DYLDLINK = $4; { the object file is input for the dynamic linker and can't be staticly link edited again }
MH_BINDATLOAD = $8; { the object file's undefined references are bound by the dynamic linker when loaded. }
MH_PREBOUND = $10; { the file has its dynamic undefined references prebound. }
MH_SPLIT_SEGS = $20; { the file has its read-only and read-write segments split }
MH_LAZY_INIT = $40; { the shared library init routine is to be run lazily via catching memory faults to its writeable segments (obsolete) }
MH_TWOLEVEL = $80; { the image is using two-level name space bindings }
MH_FORCE_FLAT = $100; { the executable is forcing all images to use flat name space bindings }
MH_NOMULTIDEFS = $200; { this umbrella guarantees no multiple defintions of symbols in its sub-images so the two-level namespace hints can always be used. }
MH_NOFIXPREBINDING = $400; { do not have dyld notify the prebinding agent about this executable }
MH_PREBINDABLE = $800; { the binary is not prebound but can have its prebinding redone. only used when MH_PREBOUND is not set. }
MH_ALLMODSBOUND = $1000; { indicates that this binary binds to all two-level namespace modules of }
{ its dependent libraries. only used when MH_PREBINDABLE and MH_TWOLEVEL are both set. }
MH_SUBSECTIONS_VIA_SYMBOLS = $2000; { safe to divide up the sections into sub-sections via symbols for dead code stripping }
MH_CANONICAL = $4000; { the binary has been canonicalized via the unprebind operation }
MH_WEAK_DEFINES = $8000; { the final linked image contains external weak symbols }
MH_BINDS_TO_WEAK = $10000; { the final linked image uses weak symbols }
MH_ALLOW_STACK_EXECUTION = $20000; { When this bit is set, all stacks in the task will be given stack }
{ execution privilege. Only used in MH_EXECUTE filetypes. }
MH_ROOT_SAFE = $40000; { When this bit is set, the binary declares it is safe for use in processes with uid zero }
MH_SETUID_SAFE = $80000; { When this bit is set, the binary declares it is safe for use in processes when issetugid() is true }
MH_NO_REEXPORTED_DYLIBS = $100000; { When this bit is set on a dylib, the static linker does not need to examine dependent dylibs to see if any are re-exported }
MH_PIE = $200000; { When this bit is set, the OS will load the main executable at a random address. Only used in MH_EXECUTE filetypes. }
{
* The load commands directly follow the mach_header. The total size of all
* of the commands is given by the sizeofcmds field in the mach_header. All
* load commands must have as their first two fields cmd and cmdsize. The cmd
* field is filled in with a constant for that command type. Each command type
* has a structure specifically for it. The cmdsize field is the size in bytes
* of the particular load command structure plus anything that follows it that
* is a part of the load command (i.e. section structures, strings, etc.). To
* advance to the next load command the cmdsize can be added to the offset or
* pointer of the current load command. The cmdsize for 32-bit architectures
* MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple
* of 8 bytes (these are forever the maximum alignment of any load commands).
* The padded bytes must be zero. All tables in the object file must also
* follow these rules so the file can be memory mapped. Otherwise the pointers
* to these tables will not work well or at all on some machines. With all
* padding zeroed like objects will compare byte for byte.
}
type
load_command = record
cmd : uint32_t; { type of load command }
cmdsize : uint32_t; { total size of command in bytes }
end;
pload_command = ^load_command;
{
* After MacOS X 10.1 when a new load command is added that is required to be
* understood by the dynamic linker for the image to execute properly the
* LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic
* linker sees such a load command it it does not understand will issue a
* "unknown load command required for execution" error and refuse to use the
* image. Other load commands without this bit that are not understood will
* simply be ignored.
}
const
LC_REQ_DYLD = $80000000;
{ Constants for the cmd field of all load commands, the type }
const
LC_SEGMENT = $1; { segment of this file to be mapped }
LC_SYMTAB = $2; { link-edit stab symbol table info }
LC_SYMSEG = $3; { link-edit gdb symbol table info (obsolete) }
LC_THREAD = $4; { thread }
LC_UNIXTHREAD = $5; { unix thread (includes a stack) }
LC_LOADFVMLIB = $6; { load a specified fixed VM shared library }
LC_IDFVMLIB = $7; { fixed VM shared library identification }
LC_IDENT = $8; { object identification info (obsolete) }
LC_FVMFILE = $9; { fixed VM file inclusion (internal use) }
LC_PREPAGE = $a; { prepage command (internal use) }
LC_DYSYMTAB = $b; { dynamic link-edit symbol table info }
LC_LOAD_DYLIB = $c; { load a dynamically linked shared library }
LC_ID_DYLIB = $d; { dynamically linked shared lib ident }
LC_LOAD_DYLINKER = $e; { load a dynamic linker }
LC_ID_DYLINKER = $f; { dynamic linker identification }
LC_PREBOUND_DYLIB = $10; { modules prebound for a dynamically linked shared library }
LC_ROUTINES = $11; { image routines }
LC_SUB_FRAMEWORK = $12; { sub framework }
LC_SUB_UMBRELLA = $13; { sub umbrella }
LC_SUB_CLIENT = $14; { sub client }
LC_SUB_LIBRARY = $15; { sub library }
LC_TWOLEVEL_HINTS = $16; { two-level namespace lookup hints }
LC_PREBIND_CKSUM = $17; { prebind checksum }
LC_LOAD_WEAK_DYLIB = $18 or LC_REQ_DYLD; { load a dynamically linked shared library that is allowed to be missing (all symbols are weak imported). }
LC_SEGMENT_64 = $19; { 64-bit segment of this file to be mapped }
LC_ROUTINES_64 = $1a; { 64-bit image routines }
LC_UUID = $1b; { the uuid }
LC_RPATH = $1c or LC_REQ_DYLD; { runpath additions }
LC_CODE_SIGNATURE = $1d; { local of code signature }
LC_SEGMENT_SPLIT_INFO = $1e; { local of info to split segments }
LC_REEXPORT_DYLIB = $1f or LC_REQ_DYLD; { load and re-export dylib }
LC_LAZY_LOAD_DYLIB = $20; { delay load of dylib until first use }
LC_ENCRYPTION_INFO = $21; { encrypted segment information }
{
* A variable length string in a load command is represented by an lc_str
* union. The strings are stored just after the load command structure and
* the offset is from the start of the load command structure. The size
* of the string is reflected in the cmdsize field of the load command.
* Once again any padded bytes to bring the cmdsize field to a multiple
* of 4 bytes must be zero.
}
{ offset to the string }
{$ifndef __LP64__}
{ pointer to the string }
{$endif}
type
lc_str = record
case longint of
0 : ( offset : uint32_t );
1 : ( ptr : ^char );
end;
{
* The segment load command indicates that a part of this file is to be
* mapped into the task's address space. The size of this segment in memory,
* vmsize, maybe equal to or larger than the amount to map from this file,
* filesize. The file is mapped starting at fileoff to the beginning of
* the segment in memory, vmaddr. The rest of the memory of the segment,
* if any, is allocated zero fill on demand. The segment's maximum virtual
* memory protection and initial virtual memory protection are specified
* by the maxprot and initprot fields. If the segment has sections then the
* section structures directly follow the segment command and their size is
* reflected in cmdsize.
}
{ for 32-bit architectures }
segment_command = record
cmd : uint32_t; { LC_SEGMENT }
cmdsize : uint32_t; { includes sizeof section structs }
segname : array[0..15] of char; { segment name }
vmaddr : uint32_t; { memory address of this segment }
vmsize : uint32_t; { memory size of this segment }
fileoff : uint32_t; { file offset of this segment }
filesize : uint32_t; { amount to map from the file }
maxprot : vm_prot_t; { maximum VM protection }
initprot : vm_prot_t; { initial VM protection }
nsects : uint32_t; { number of sections in segment }
flags : uint32_t; { flags }
end;
psegment_command = ^segment_command;
{
* The 64-bit segment load command indicates that a part of this file is to be
* mapped into a 64-bit task's address space. If the 64-bit segment has
* sections then section_64 structures directly follow the 64-bit segment
* command and their size is reflected in cmdsize.
}
{ for 64-bit architectures }
segment_command_64 = record
cmd : uint32_t; { LC_SEGMENT_64 }
cmdsize : uint32_t; { includes sizeof section_64 structs }
segname : array[0..15] of char; { segment name }
vmaddr : uint64_t; { memory address of this segment }
vmsize : uint64_t; { memory size of this segment }
fileoff : uint64_t; { file offset of this segment }
filesize : uint64_t; { amount to map from the file }
maxprot : vm_prot_t; { maximum VM protection }
initprot : vm_prot_t; { initial VM protection }
nsects : uint32_t; { number of sections in segment }
flags : uint32_t; { flags }
end;
psegment_command_64 = ^segment_command_64;
{ Constants for the flags field of the segment_command }
const
SG_HIGHVM = $1; { the file contents for this segment is for }
{ the high part of the VM space, the low part }
{ is zero filled (for stacks in core files) }
SG_FVMLIB = $2; { this segment is the VM that is allocated by }
{ a fixed VM library, for overlap checking in }
{ the link editor }
SG_NORELOC = $4; { this segment has nothing that was relocated }
{ in it and nothing relocated to it, that is }
{ it maybe safely replaced without relocation }
SG_PROTECTED_VERSION_1 = $8; { This segment is protected. If the }
{ segment starts at file offset 0, the }
{ first page of the segment is not }
{ protected. All other pages of the }
{ segment are protected. }
{* A segment is made up of zero or more sections. Non-MH_OBJECT files have
* all of their segments with the proper sections in each, and padded to the
* specified segment alignment when produced by the link editor. The first
* segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header
* and load commands of the object file before its first section. The zero
* fill sections are always last in their segment (in all formats). This
* allows the zeroed segment padding to be mapped into memory where zero fill
* sections might be. The gigabyte zero fill sections, those with the section
* type S_GB_ZEROFILL, can only be in a segment with sections of this type.
* These segments are then placed after all other segments.
*
* The MH_OBJECT format has all of its sections in one segment for
* compactness. There is no padding to a specified segment boundary and the
* mach_header and load commands are not part of the segment.
*
* Sections with the same section name, sectname, going into the same segment,
* segname, are combined by the link editor. The resulting section is aligned
* to the maximum alignment of the combined sections and is the new section's
* alignment. The combined sections are aligned to their original alignment in
* the combined section. Any padded bytes to get the specified alignment are
* zeroed.
*
* The format of the relocation entries referenced by the reloff and nreloc
* fields of the section structure for mach object files is described in the
* header file <reloc.h>. }
type
{ for 32-bit architectures }
section = record
sectname : array[0..15] of char; { name of this section }
segname : array[0..15] of char; { segment this section goes in }
addr : uint32_t; { memory address of this section }
size : uint32_t; { size in bytes of this section }
offset : uint32_t; { file offset of this section }
align : uint32_t; { section alignment (power of 2) }
reloff : uint32_t; { file offset of relocation entries }
nreloc : uint32_t; { number of relocation entries }
flags : uint32_t; { flags (section type and attributes) }
reserved1 : uint32_t; { reserved (for offset or index) }
reserved2 : uint32_t; { reserved (for count or sizeof) }
end;
psection = ^section;
{ for 64-bit architectures }
section_64 = record
sectname : array[0..15] of char; { name of this section }
segname : array[0..15] of char; { segment this section goes in }
addr : uint64_t; { memory address of this section }
size : uint64_t; { size in bytes of this section }
offset : uint32_t; { file offset of this section }
align : uint32_t; { section alignment (power of 2) }
reloff : uint32_t; { file offset of relocation entries }
nreloc : uint32_t; { number of relocation entries }
flags : uint32_t; { flags (section type and attributes) }
reserved1 : uint32_t; { reserved (for offset or index) }
reserved2 : uint32_t; { reserved (for count or sizeof) }
reserved3 : uint32_t; { reserved }
end;
psection_64 = ^section_64;
{* The flags field of a section structure is separated into two parts a section
* type and section attributes. The section types are mutually exclusive (it
* can only have one type) but the section attributes are not (it may have more
* than one attribute). }
{ 256 section types }
const
SECTION_TYPE = $000000ff; { Constants for the type of a section }
SECTION_ATTRIBUTES = $ffffff00; { 24 section attributes }
S_REGULAR = $0; { regular section }
S_ZEROFILL = $1; { zero fill on demand section }
S_CSTRING_LITERALS = $2; { section with only literal C strings }
S_4BYTE_LITERALS = $3; { section with only 4 byte literals }
S_8BYTE_LITERALS = $4; { section with only 8 byte literals }
S_LITERAL_POINTERS = $5; { section with only pointers to literals }
{* For the two types of symbol pointers sections and the symbol stubs section
* they have indirect symbol table entries. For each of the entries in the
* section the indirect symbol table entries, in corresponding order in the
* indirect symbol table, start at the index stored in the reserved1 field
* of the section structure. Since the indirect symbol table entries
* correspond to the entries in the section the number of indirect symbol table
* entries is inferred from the size of the section divided by the size of the
* entries in the section. For symbol pointers sections the size of the entries
* in the section is 4 bytes and for symbol stubs sections the byte size of the
* stubs is stored in the reserved2 field of the section structure. }
S_NON_LAZY_SYMBOL_POINTERS = $6; { section with only non-lazy symbol pointers }
S_LAZY_SYMBOL_POINTERS = $7; { section with only lazy symbol pointers }
S_SYMBOL_STUBS = $8; { section with only symbol stubs, byte size of stub in the reserved2 field }
S_MOD_INIT_FUNC_POINTERS = $9; { section with only function pointers for initialization }
S_MOD_TERM_FUNC_POINTERS = $a; { section with only function pointers for termination }
S_COALESCED = $b; { section contains symbols that are to be coalesced }
S_GB_ZEROFILL = $c; { zero fill on demand section (that can be larger than 4 gigabytes) }
S_INTERPOSING = $d; { section with only pairs of function pointers for interposing }
S_16BYTE_LITERALS = $e; { section with only 16 byte literals }
S_DTRACE_DOF = $f; { section contains DTrace Object Format }
S_LAZY_DYLIB_SYMBOL_POINTERS = $10; { section with only lazy symbol pointers to lazy loaded dylibs }
{* Constants for the section attributes part of the flags field of a section structure. }
SECTION_ATTRIBUTES_USR = $ff000000; { User setable attributes }
S_ATTR_PURE_INSTRUCTIONS = $80000000; { section contains only true machine instructions }
S_ATTR_NO_TOC = $40000000; { section contains coalesced symbols }
{ that are not to be in a ranlib table of contents }
S_ATTR_STRIP_STATIC_SYMS = $20000000; { ok to strip static symbols this section }
{ in files with the MH_DYLDLINK flag }
S_ATTR_NO_DEAD_STRIP = $10000000; { no dead stripping }
S_ATTR_LIVE_SUPPORT = $08000000; { blocks are live if they reference live blocks }
S_ATTR_SELF_MODIFYING_CODE = $04000000; { Used with i386 code stubs written on by dyld }
{
* If a segment contains any sections marked with S_ATTR_DEBUG then all
* sections in that segment must have this attribute. No section other than
* a section marked with this attribute may reference the contents of this
* section. A section with this attribute may contain no symbols and must have
* a section type S_REGULAR. The static linker will not copy section contents
* from sections with this attribute into its output file. These sections
* generally contain DWARF debugging info.
} { a debug section }
S_ATTR_DEBUG = $02000000;
{ system setable attributes }
SECTION_ATTRIBUTES_SYS = $00ffff00;
{ section contains some
machine instructions }
S_ATTR_SOME_INSTRUCTIONS = $00000400;
{ section has external
relocation entries }
S_ATTR_EXT_RELOC = $00000200;
{ section has local
relocation entries }
S_ATTR_LOC_RELOC = $00000100;
{
* The names of segments and sections in them are mostly meaningless to the
* link-editor. But there are few things to support traditional UNIX
* executables that require the link-editor and assembler to use some names
* agreed upon by convention.
*
* The initial protection of the "__TEXT" segment has write protection turned
* off (not writeable).
*
* The link-editor will allocate common symbols at the end of the "__common"
* section in the "__DATA" segment. It will create the section and segment
* if needed.
}
{ The currently known segment names and the section names in those segments }
SEG_PAGEZERO = '__PAGEZERO'; { the pagezero segment which has no }
{ protections and catches NULL references for MH_EXECUTE files }
SEG_TEXT = '__TEXT'; { the tradition UNIX text segment }
SECT_TEXT = '__text'; { the real text part of the text }
SECT_FVMLIB_INIT0 = '__fvmlib_init0'; { the fvmlib initialization section }
SECT_FVMLIB_INIT1 = '__fvmlib_init1'; { the section following the fvmlib initialization section }
SEG_DATA = '__DATA'; { the tradition UNIX data segment }
SECT_DATA = '__data'; { the real initialized data section no padding, no bss overlap }
SECT_BSS = '__bss'; { the real uninitialized data section no padding }
SECT_COMMON = '__common'; { the section common symbols are allocated in by the link editor }
SEG_OBJC = '__OBJC'; { objective-C runtime segment }
SECT_OBJC_SYMBOLS = '__symbol_table'; { symbol table }
SECT_OBJC_MODULES = '__module_info'; { module information }
SECT_OBJC_STRINGS = '__selector_strs'; { string table }
SECT_OBJC_REFS = '__selector_refs'; { string table }
SEG_ICON = '__ICON'; { the icon segment }
SECT_ICON_HEADER = '__header'; { the icon headers }
SECT_ICON_TIFF = '__tiff'; { the icons in tiff format }
SEG_LINKEDIT = '__LINKEDIT'; { the segment containing all structs }
{ created and maintained by the linkeditor. }
{ Created with -seglinkedit option to ld(1) for MH_EXECUTE and FVMLIB file types only }
SEG_UNIXSTACK = '__UNIXSTACK'; { the unix stack segment }
SEG_IMPORT = '__IMPORT'; { the segment for the self (dyld) }
{ modifing code stubs that has read, write and execute permissions }
{* Fixed virtual memory shared libraries are identified by two things. The
* target pathname (the name of the library as found for execution), and the
* minor version number. The address of where the headers are loaded is in
* header_addr. (THIS IS OBSOLETE and no longer supported). }
type
fvmlib = record
name : lc_str; { library's target pathname }
minor_version : uint32_t; { library's minor version number }
header_addr : uint32_t; { library's header address }
end;
{* A fixed virtual shared library (filetype == MH_FVMLIB in the mach header)
* contains a fvmlib_command (cmd == LC_IDFVMLIB) to identify the library.
* An object that uses a fixed virtual shared library also contains a
* fvmlib_command (cmd == LC_LOADFVMLIB) for each library it uses.
* (THIS IS OBSOLETE and no longer supported). }
fvmlib_command = record
cmd : uint32_t; { LC_IDFVMLIB or LC_LOADFVMLIB }
cmdsize : uint32_t; { includes pathname string }
fvmlib : fvmlib; { the library identification }
end;
pfvmlib_command = ^fvmlib_command;
{* Dynamicly linked shared libraries are identified by two things. The
* pathname (the name of the library as found for execution), and the
* compatibility version number. The pathname must match and the compatibility
* number in the user of the library must be greater than or equal to the
* library being used. The time stamp is used to record the time a library was
* built and copied into user so it can be use to determined if the library used
* at runtime is exactly the same as used to built the program. }
dylib = record
name : lc_str; { library's path name }
timestamp : uint32_t; { library's build time stamp }
current_version : uint32_t; { library's current version number }
compatibility_version : uint32_t; { library's compatibility vers number }
end;
{* A dynamically linked shared library (filetype == MH_DYLIB in the mach header)
* contains a dylib_command (cmd == LC_ID_DYLIB) to identify the library.
* An object that uses a dynamically linked shared library also contains a
* dylib_command (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or
* LC_REEXPORT_DYLIB) for each library it uses. }
dylib_command = record
cmd : uint32_t; { LC_ID_DYLIB, LC_LOAD_DYLIB,WEAK_DYLIB, LC_REEXPORT_DYLIB }
cmdsize : uint32_t; { includes pathname string }
dylib : dylib; { the library identification }
end;
pdylib_command = ^dylib_command;
{* A dynamically linked shared library may be a subframework of an umbrella
* framework. If so it will be linked with "-umbrella umbrella_name" where
* Where "umbrella_name" is the name of the umbrella framework. A subframework
* can only be linked against by its umbrella framework or other subframeworks
* that are part of the same umbrella framework. Otherwise the static link
* editor produces an error and states to link against the umbrella framework.
* The name of the umbrella framework for subframeworks is recorded in the
* following structure. }
sub_framework_command = record
cmd : uint32_t; { LC_SUB_FRAMEWORK }
cmdsize : uint32_t; { includes umbrella string }
umbrella : lc_str; { the umbrella framework name }
end;
psub_framework_command = ^sub_framework_command;
{* For dynamically linked shared libraries that are subframework of an umbrella
* framework they can allow clients other than the umbrella framework or other
* subframeworks in the same umbrella framework. To do this the subframework
* is built with "-allowable_client client_name" and an LC_SUB_CLIENT load
* command is created for each -allowable_client flag. The client_name is
* usually a framework name. It can also be a name used for bundles clients
* where the bundle is built with "-client_name client_name". }
sub_client_command = record
cmd : uint32_t; { LC_SUB_CLIENT }
cmdsize : uint32_t; { includes client string }
client : lc_str; { the client name }
end;
psub_client_command = ^sub_client_command;
{
* A dynamically linked shared library may be a sub_umbrella of an umbrella
* framework. If so it will be linked with "-sub_umbrella umbrella_name" where
* Where "umbrella_name" is the name of the sub_umbrella framework. When
* staticly linking when -twolevel_namespace is in effect a twolevel namespace
* umbrella framework will only cause its subframeworks and those frameworks
* listed as sub_umbrella frameworks to be implicited linked in. Any other
* dependent dynamic libraries will not be linked it when -twolevel_namespace
* is in effect. The primary library recorded by the static linker when
* resolving a symbol in these libraries will be the umbrella framework.
* Zero or more sub_umbrella frameworks may be use by an umbrella framework.
* The name of a sub_umbrella framework is recorded in the following structure.
}
sub_umbrella_command = record
cmd : uint32_t; { LC_SUB_UMBRELLA }
cmdsize : uint32_t; { includes sub_umbrella string }
sub_umbrella : lc_str; { the sub_umbrella framework name }
end;
{* A dynamically linked shared library may be a sub_library of another shared
* library. If so it will be linked with "-sub_library library_name" where
* Where "library_name" is the name of the sub_library shared library. When
* staticly linking when -twolevel_namespace is in effect a twolevel namespace
* shared library will only cause its subframeworks and those frameworks
* listed as sub_umbrella frameworks and libraries listed as sub_libraries to
* be implicited linked in. Any other dependent dynamic libraries will not be
* linked it when -twolevel_namespace is in effect. The primary library
* recorded by the static linker when resolving a symbol in these libraries
* will be the umbrella framework (or dynamic library). Zero or more sub_library
* shared libraries may be use by an umbrella framework or (or dynamic library).
* The name of a sub_library framework is recorded in the following structure.
* For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc".}
sub_library_command = record
cmd : uint32_t; { LC_SUB_LIBRARY }
cmdsize : uint32_t; { includes sub_library string }
sub_library : lc_str; { the sub_library name }
end;
psub_library_command = ^sub_library_command;
{* A program (filetype == MH_EXECUTE) that is
* prebound to its dynamic libraries has one of these for each library that
* the static linker used in prebinding. It contains a bit vector for the
* modules in the library. The bits indicate which modules are bound (1) and
* which are not (0) from the library. The bit for module 0 is the low bit
* of the first byte. So the bit for the Nth module is:
* (linked_modules[N/8] >> N%8) & 1 }
prebound_dylib_command = record
cmd : uint32_t; { LC_PREBOUND_DYLIB }
cmdsize : uint32_t; { includes strings }
name : lc_str; { library's path name }
nmodules : uint32_t; { number of modules in library }
linked_modules : lc_str; { bit vector of linked modules }
end;
pprebound_dylib_command = ^prebound_dylib_command;
{* A program that uses a dynamic linker contains a dylinker_command to identify
* the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic linker
* contains a dylinker_command to identify the dynamic linker (LC_ID_DYLINKER).
* A file can have at most one of these.}
dylinker_command = record
cmd : uint32_t; { LC_ID_DYLINKER or LC_LOAD_DYLINKER }
cmdsize : uint32_t; { includes pathname string }
name : lc_str; { dynamic linker's path name }
end;
pdylinker_command = ^dylinker_command;
{
* Thread commands contain machine-specific data structures suitable for
* use in the thread state primitives. The machine specific data structures
* follow the struct thread_command as follows.
* Each flavor of machine specific data structure is preceded by an unsigned
* long constant for the flavor of that data structure, an uint32_t
* that is the count of longs of the size of the state data structure and then
* the state data structure follows. This triple may be repeated for many
* flavors. The constants for the flavors, counts and state data structure
* definitions are expected to be in the header file <machine/thread_status.h>.
* These machine specific data structures sizes must be multiples of
* 4 bytes The cmdsize reflects the total size of the thread_command
* and all of the sizes of the constants for the flavors, counts and state
* data structures.
*
* For executable objects that are unix processes there will be one
* thread_command (cmd == LC_UNIXTHREAD) created for it by the link-editor.
* This is the same as a LC_THREAD, except that a stack is automatically
* created (based on the shell's limit for the stack size). Command arguments
* and environment variables are copied onto that stack.
}
thread_command = record
cmd : uint32_t; { LC_THREAD or LC_UNIXTHREAD }
cmdsize : uint32_t; { total size of this command }
flavor : uint32_t; { uint32_t flavor flavor of thread state }
count : uint32_t; { uint32_t count count of longs in thread state }
{ struct XXX_thread_state state thread state for this flavor }
{ ... }
end;
pthread_command = ^thread_command;
{* The routines command contains the address of the dynamic shared library
* initialization routine and an index into the module table for the module
* that defines the routine. Before any modules are used from the library the
* dynamic linker fully binds the module that defines the initialization routine
* and then calls it. This gets called before any module initialization
* routines (used for C++ static constructors) in the library. }
{ for 32-bit architectures }
routines_command = record
cmd : uint32_t; { LC_ROUTINES }
cmdsize : uint32_t; { total size of this command }
init_address : uint32_t; { address of initialization routine }
init_module : uint32_t; { index into the module table that the init routine is defined in }
reserved1 : uint32_t;
reserved2 : uint32_t;
reserved3 : uint32_t;
reserved4 : uint32_t;
reserved5 : uint32_t;
reserved6 : uint32_t;
end;
proutines_command = ^routines_command;
{ * The 64-bit routines command. Same use as above. }
{ for 64-bit architectures }
routines_command_64 = record
cmd : uint32_t; { LC_ROUTINES_64 }
cmdsize : uint32_t; { total size of this command }
init_address : uint64_t; { address of initialization routine }
init_module : uint64_t; { index into the module table that }
{ the init routine is defined in }
reserved1 : uint64_t;
reserved2 : uint64_t;
reserved3 : uint64_t;
reserved4 : uint64_t;
reserved5 : uint64_t;
reserved6 : uint64_t;
end;
proutines_command_64 = ^routines_command_64;
{* The symtab_command contains the offsets and sizes of the link-edit 4.3BSD
* "stab" style symbol table information as described in the header files
* <nlist.h> and <stab.h>.
}
symtab_command = record
cmd : uint32_t; { LC_SYMTAB }
cmdsize : uint32_t; { sizeof(struct symtab_command) }
symoff : uint32_t; { symbol table offset }
nsyms : uint32_t; { number of symbol table entries }
stroff : uint32_t; { string table offset }
strsize : uint32_t; { string table size in bytes }
end;
psymtab_command = ^symtab_command;
{
* This is the second set of the symbolic information which is used to support
* the data structures for the dynamically link editor.
*
* The original set of symbolic information in the symtab_command which contains
* the symbol and string tables must also be present when this load command is
* present. When this load command is present the symbol table is organized
* into three groups of symbols:
* local symbols (static and debugging symbols) - grouped by module
* defined external symbols - grouped by module (sorted by name if not lib)
* undefined external symbols (sorted by name if MH_BINDATLOAD is not set,
* and in order the were seen by the static
* linker if MH_BINDATLOAD is set)
* In this load command there are offsets and counts to each of the three groups
* of symbols.
*
* This load command contains a the offsets and sizes of the following new
* symbolic information tables:
* table of contents
* module table
* reference symbol table
* indirect symbol table
* The first three tables above (the table of contents, module table and
* reference symbol table) are only present if the file is a dynamically linked
* shared library. For executable and object modules, which are files
* containing only one module, the information that would be in these three
* tables is determined as follows:
* table of contents - the defined external symbols are sorted by name
* module table - the file contains only one module so everything in the
* file is part of the module.
* reference symbol table - is the defined and undefined external symbols
*
* For dynamically linked shared library files this load command also contains
* offsets and sizes to the pool of relocation entries for all sections
* separated into two groups:
* external relocation entries
* local relocation entries
* For executable and object modules the relocation entries continue to hang
* off the section structures.
}
dysymtab_command = record
cmd : uint32_t; { LC_DYSYMTAB }
cmdsize : uint32_t; { sizeof(struct dysymtab_command) }
{
* The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
* are grouped into the following three groups:
* local symbols (further grouped by the module they are from)
* defined external symbols (further grouped by the module they are from)
* undefined symbols
*
* The local symbols are used only for debugging. The dynamic binding
* process may have to use them to indicate to the debugger the local
* symbols for a module that is being bound.
*
* The last two groups are used by the dynamic binding process to do the
* binding (indirectly through the module table and the reference symbol
* table when this is a dynamically linked shared library file).
}
ilocalsym : uint32_t; { index to local symbols }
nlocalsym : uint32_t; { number of local symbols }
iextdefsym : uint32_t; { index to externally defined symbols }
nextdefsym : uint32_t; { number of externally defined symbols }
iundefsym : uint32_t; { index to undefined symbols }
nundefsym : uint32_t; { number of undefined symbols }
{
* For the for the dynamic binding process to find which module a symbol
* is defined in the table of contents is used (analogous to the ranlib
* structure in an archive) which maps defined external symbols to modules
* they are defined in. This exists only in a dynamically linked shared
* library file. For executable and object modules the defined external
* symbols are sorted by name and is use as the table of contents.
}
tocoff : uint32_t; { file offset to table of contents }
ntoc : uint32_t; { number of entries in table of contents }
{
* To support dynamic binding of "modules" (whole object files) the symbol
* table must reflect the modules that the file was created from. This is
* done by having a module table that has indexes and counts into the merged
* tables for each module. The module structure that these two entries
* refer to is described below. This exists only in a dynamically linked
* shared library file. For executable and object modules the file only
* contains one module so everything in the file belongs to the module.
}
modtaboff : uint32_t; { file offset to module table }
nmodtab : uint32_t; { number of module table entries }
{
* To support dynamic module binding the module structure for each module
* indicates the external references (defined and undefined) each module
* makes. For each module there is an offset and a count into the
* reference symbol table for the symbols that the module references.
* This exists only in a dynamically linked shared library file. For
* executable and object modules the defined external symbols and the
* undefined external symbols indicates the external references.
}
extrefsymoff : uint32_t; { offset to referenced symbol table }
nextrefsyms : uint32_t; { number of referenced symbol table entries }
{
* The sections that contain "symbol pointers" and "routine stubs" have
* indexes and (implied counts based on the size of the section and fixed
* size of the entry) into the "indirect symbol" table for each pointer
* and stub. For every section of these two types the index into the
* indirect symbol table is stored in the section header in the field
* reserved1. An indirect symbol table entry is simply a 32bit index into
* the symbol table to the symbol that the pointer or stub is referring to.
* The indirect symbol table is ordered to match the entries in the section.
}
indirectsymoff : uint32_t; { file offset to the indirect symbol table }
nindirectsyms : uint32_t; { number of indirect symbol table entries }
{ * To support relocating an individual module in a library file quickly the
* external relocation entries for each module in the library need to be
* accessed efficiently. Since the relocation entries can't be accessed
* through the section headers for a library file they are separated into
* groups of local and external entries further grouped by module. In this
* case the presents of this load command who's extreloff, nextrel,
* locreloff and nlocrel fields are non-zero indicates that the relocation
* entries of non-merged sections are not referenced through the section
* structures (and the reloff and nreloc fields in the section headers are
* set to zero).
*
* Since the relocation entries are not accessed through the section headers
* this requires the r_address field to be something other than a section
* offset to identify the item to be relocated. In this case r_address is
* set to the offset from the vmaddr of the first LC_SEGMENT command.
* For MH_SPLIT_SEGS images r_address is set to the the offset from the
* vmaddr of the first read-write LC_SEGMENT command.
*
* The relocation entries are grouped by module and the module table
* entries have indexes and counts into them for the group of external
* relocation entries for that the module.
*
* For sections that are merged across modules there must not be any
* remaining external relocation entries for them (for merged sections
* remaining relocation entries must be local).
}
extreloff : uint32_t; { offset to external relocation entries }
nextrel : uint32_t; { number of external relocation entries }
{ * All the local relocation entries are grouped together (they are not
* grouped by their module since they are only used if the object is moved
* from it staticly link edited address). }
locreloff : uint32_t; { offset to local relocation entries }
nlocrel : uint32_t; { number of local relocation entries }
end;
{
* An indirect symbol table entry is simply a 32bit index into the symbol table
* to the symbol that the pointer or stub is refering to. Unless it is for a
* non-lazy symbol pointer section for a defined symbol which strip(1) as
* removed. In which case it has the value INDIRECT_SYMBOL_LOCAL. If the
* symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that.
}
const
INDIRECT_SYMBOL_LOCAL = $80000000;
INDIRECT_SYMBOL_ABS = $40000000;
type
dylib_table_of_contents = record { a table of contents entry }
symbol_index : uint32_t; { the defined external symbol (index into the symbol table) }
module_index : uint32_t; { index into the module table this symbol is defined in }
end;
dylib_module = record { a module table entry }
module_name : uint32_t; { the module name (index into string table) }
iextdefsym : uint32_t; { index into externally defined symbols }
nextdefsym : uint32_t; { number of externally defined symbols }
irefsym : uint32_t; { index into reference symbol table }
nrefsym : uint32_t; { number of reference symbol table entries }
ilocalsym : uint32_t; { index into symbols for local symbols }
nlocalsym : uint32_t; { number of local symbols }
iextrel : uint32_t; { index into external relocation entries }
nextrel : uint32_t; { number of external relocation entries }
iinit_iterm : uint32_t; { low 16 bits are the index into the init
section, high 16 bits are the index into
the term section }
ninit_nterm : uint32_t; { low 16 bits are the number of init section
entries, high 16 bits are the number of
term section entries }
objc_module_info_addr : uint32_t; { for this module address of the start of the (__OBJC,__module_info) section }
objc_module_info_size : uint32_t; { for this module size of the (__OBJC,__module_info) section }
end;
dylib_module_64 = record { a 64-bit module table entry }
module_name : uint32_t; { the module name (index into string table) }
iextdefsym : uint32_t; { index into externally defined symbols }
nextdefsym : uint32_t; { number of externally defined symbols }
irefsym : uint32_t; { index into reference symbol table }
nrefsym : uint32_t; { number of reference symbol table entries }
ilocalsym : uint32_t; { index into symbols for local symbols }
nlocalsym : uint32_t; { number of local symbols }
iextrel : uint32_t; { index into external relocation entries }
nextrel : uint32_t; { number of external relocation entries }
iinit_iterm : uint32_t; { low 16 bits are the index into the init
section, high 16 bits are the index into
the term section }
ninit_nterm : uint32_t; { low 16 bits are the number of init section
entries, high 16 bits are the number of
term section entries }
objc_module_info_size : uint32_t; { for this module size of the (__OBJC,__module_info) section }
objc_module_info_addr : uint64_t; { for this module address of the start of the (__OBJC,__module_info) section }
end;
{
* The entries in the reference symbol table are used when loading the module
* (both by the static and dynamic link editors) and if the module is unloaded
* or replaced. Therefore all external symbols (defined and undefined) are
* listed in the module's reference table. The flags describe the type of
* reference that is being made. The constants for the flags are defined in
* <mach-o/nlist.h> as they are also used for symbol table entries.
}
{ index into the symbol table }
{ flags to indicate the type of reference }
dylib_reference = record
flag0 : longint;
end;
{ const
bm_dylib_reference_isym = $FFFFFF;
bp_dylib_reference_isym = 0;
bm_dylib_reference_flags = $FF000000;
bp_dylib_reference_flags = 24;
function isym(var a : dylib_reference) : uint32_t;
procedure set_isym(var a : dylib_reference; __isym : uint32_t);
function flags(var a : dylib_reference) : uint32_t;
procedure set_flags(var a : dylib_reference; __flags : uint32_t);}
{* The twolevel_hints_command contains the offset and number of hints in the
* two-level namespace lookup hints table.}
type
twolevel_hints_command = record
cmd : uint32_t; { LC_TWOLEVEL_HINTS }
cmdsize : uint32_t; { sizeof(struct twolevel_hints_command) }
offset : uint32_t; { offset to the hint table }
nhints : uint32_t; { number of hints in the hint table }
end;
{
* The entries in the two-level namespace lookup hints table are twolevel_hint
* structs. These provide hints to the dynamic link editor where to start
* looking for an undefined symbol in a two-level namespace image. The
* isub_image field is an index into the sub-images (sub-frameworks and
* sub-umbrellas list) that made up the two-level image that the undefined
* symbol was found in when it was built by the static link editor. If
* isub-image is 0 the the symbol is expected to be defined in library and not
* in the sub-images. If isub-image is non-zero it is an index into the array
* of sub-images for the umbrella with the first index in the sub-images being
* 1. The array of sub-images is the ordered list of sub-images of the umbrella
* that would be searched for a symbol that has the umbrella recorded as its
* primary library. The table of contents index is an index into the
* library's table of contents. This is used as the starting point of the
* binary search or a directed linear search.
}
{ index into the sub images }
{ index into the table of contents }
twolevel_hint = record
flag0 : longint;
end;
{ const
bm_twolevel_hint_isub_image = $FF;
bp_twolevel_hint_isub_image = 0;
bm_twolevel_hint_itoc = $FFFFFF00;
bp_twolevel_hint_itoc = 8;
function isub_image(var a : twolevel_hint) : uint32_t;
procedure set_isub_image(var a : twolevel_hint; __isub_image : uint32_t);
function itoc(var a : twolevel_hint) : uint32_t;
procedure set_itoc(var a : twolevel_hint; __itoc : uint32_t);
}
type
{* The prebind_cksum_command contains the value of the original check sum for
* prebound files or zero. When a prebound file is first created or modified
* for other than updating its prebinding information the value of the check sum
* is set to zero. When the file has it prebinding re-done and if the value of
* the check sum is zero the original check sum is calculated and stored in
* cksum field of this load command in the output file. If when the prebinding
* is re-done and the cksum field is non-zero it is left unchanged from the
* input file. }
prebind_cksum_command = record
cmd : uint32_t; { LC_PREBIND_CKSUM }
cmdsize : uint32_t; { sizeof(struct prebind_cksum_command) }
cksum : uint32_t; { the check sum or zero }
end;
pprebind_cksum_command = ^prebind_cksum_command;
{* The uuid load command contains a single 128-bit unique random number that
* identifies an object produced by the static link editor. }
uuid_command = record
cmd : uint32_t; { LC_UUID }
cmdsize : uint32_t; { sizeof(struct uuid_command) }
uuid : array[0..15] of uint8_t; { the 128-bit uuid }
end;
puuid_command = ^uuid_command;
{* The rpath_command contains a path which at runtime should be added to
* the current run path used to find @rpath prefixed dylibs.}
rpath_command = record
cmd : uint32_t; { LC_RPATH }
cmdsize : uint32_t; { includes string }
path : lc_str; { path to add to run path }
end;
prpath_command = ^rpath_command;
{* The linkedit_data_command contains the offsets and sizes of a blob
* of data in the __LINKEDIT segment.}
linkedit_data_command = record
cmd : uint32_t; { LC_CODE_SIGNATURE or LC_SEGMENT_SPLIT_INFO }
cmdsize : uint32_t; { sizeof(struct linkedit_data_command) }
dataoff : uint32_t; { file offset of data in __LINKEDIT segment }
datasize : uint32_t; { file size of data in __LINKEDIT segment }
end;
plinkedit_data_command = ^linkedit_data_command;
{* The encryption_info_command contains the file offset and size of an
* of an encrypted segment.}
encryption_info_command = record
cmd : uint32_t; { LC_ENCRYPTION_INFO }
cmdsize : uint32_t; { sizeof(struct encryption_info_command) }
cryptoff : uint32_t; { file offset of encrypted range }
cryptsize : uint32_t; { file size of encrypted range }
cryptid : uint32_t; { which enryption system, 0 means not-encrypted yet }
end;
pencryption_info_command = ^encryption_info_command;
{* The symseg_command contains the offset and size of the GNU style
* symbol table information as described in the header file <symseg.h>.
* The symbol roots of the symbol segments must also be aligned properly
* in the file. So the requirement of keeping the offsets aligned to a
* multiple of a 4 bytes translates to the length field of the symbol
* roots also being a multiple of a long. Also the padding must again be
* zeroed. (THIS IS OBSOLETE and no longer supported). }
symseg_command = record
cmd : uint32_t; { LC_SYMSEG }
cmdsize : uint32_t; { sizeof(struct symseg_command) }
offset : uint32_t; { symbol segment offset }
size : uint32_t; { symbol segment size in bytes }
end;
psymseg_command = ^symseg_command;
{* The ident_command contains a free format string table following the
* ident_command structure. The strings are null terminated and the size of
* the command is padded out with zero bytes to a multiple of 4 bytes/
* (THIS IS OBSOLETE and no longer supported).}
ident_command = record
cmd : uint32_t; { LC_IDENT }
cmdsize : uint32_t; { strings that follow this command }
end;
pident_command = ^ident_command;
{* The fvmfile_command contains a reference to a file to be loaded at the
* specified virtual address. (Presently, this command is reserved for
* internal use. The kernel ignores this command when loading a program into
* memory). }
fvmfile_command = record
cmd : uint32_t; { LC_FVMFILE }
cmdsize : uint32_t; { includes pathname string }
name : lc_str; { files pathname }
header_addr : uint32_t; { files virtual address }
end;
pfvmfile_command = ^fvmfile_command;
{* This header file describes the structures of the file format for "fat"
* architecture specific file (wrapper design). At the begining of the file
* there is one fat_header structure followed by a number of fat_arch
* structures. For each architecture in the file, specified by a pair of
* cputype and cpusubtype, the fat_header describes the file offset, file
* size and alignment in the file of the architecture specific member.
* The padded bytes in the file to place each member on it's specific alignment
* are defined to be read as zeros and can be left as "holes" if the file system
* can support them as long as they read as zeros.
*
* All structures defined here are always written and read to/from disk
* in big-endian order.}
{* <mach/machine.h> is needed here for the cpu_type_t and cpu_subtype_t types
* and contains the constants for the possible values of these types.}
const
FAT_MAGIC = $cafebabe;
FAT_CIGAM = $bebafeca;
type
fat_header = record
magic : uint32_t; { FAT_MAGIC }
nfat_arch : uint32_t; { number of structs that follow }
end;
fat_arch = record
cputype : cpu_type_t; { cpu specifier (int) }
cpusubtype : cpu_subtype_t; { machine specifier (int) }
offset : uint32_t; { file offset to this object file }
size : uint32_t; { size of this object file }
align : uint32_t; { alignment as a power of 2 }
end;
{
* Format of a symbol table entry of a Mach-O file for 32-bit architectures.
* Modified from the BSD format. The modifications from the original format
* were changing n_other (an unused field) to n_sect and the addition of the
* N_SECT type. These modifications are required to support symbols in a larger
* number of sections not just the three sections (text, data and bss) in a BSD
* file.
}
type
nlist = record
n_un : record
case longint of
{$ifndef __LP64__}
0 : ( n_name : Pchar ); { for use when in-core }
{$endif}
1 : ( n_strx : int32_t ); { index into the string table }
end;
n_type : uint8_t; { type flag, see below }
n_sect : uint8_t; { section number or NO_SECT }
n_desc : int16_t; { see <mach-o/stab.h> }
n_value : uint32_t; { value of this symbol (or stab offset) }
end;
pnlist = ^nlist;
{* This is the symbol table entry structure for 64-bit architectures.}
nlist_64 = record
n_un : record
case longint of
0 : ( n_strx : uint32_t ); { index into the string table }
end;
n_type : uint8_t; { type flag, see below }
n_sect : uint8_t; { section number or NO_SECT }
n_desc : uint16_t; { see <mach-o/stab.h> }
n_value : uint64_t; { value of this symbol (or stab offset) }
end;
pnlist_64 = ^nlist_64;
{* Symbols with a index into the string table of zero (n_un.n_strx == 0) are
* defined to have a null, "", name. Therefore all string indexes to non null
* names must not have a zero string index. This is bit historical information
* that has never been well documented. }
{* The n_type field really contains four fields:
* unsigned char N_STAB:3,
* N_PEXT:1,
* N_TYPE:3,
* N_EXT:1;
* which are used via the following masks.}
const
N_STAB = $e0; { if any of these bits set, a symbolic debugging entry }
N_PEXT = $10; { private external symbol bit }
N_TYPE = $0e; { mask for the type bits }
N_EXT = $01; { external symbol bit, set for external symbols }
{* Only symbolic debugging entries have some of the N_STAB bits set and if any
* of these bits are set then it is a symbolic debugging entry (a stab). In
* which case then the values of the n_type field (the entire field) are given
* in <mach-o/stab.h> }
{* Values for N_TYPE bits of the n_type field. }
N_UNDF = $0; { undefined, n_sect == NO_SECT }
N_ABS = $2; { absolute, n_sect == NO_SECT }
N_SECT = $e; { defined in section number n_sect }
N_PBUD = $c; { prebound undefined (defined in a dylib) }
N_INDR = $a; { indirect }
{* If the type is N_INDR then the symbol is defined to be the same as another
* symbol. In this case the n_value field is an index into the string table
* of the other symbol's name. When the other symbol is defined then they both
* take on the defined type and value.}
{* If the type is N_SECT then the n_sect field contains an ordinal of the
* section the symbol is defined in. The sections are numbered from 1 and
* refer to sections in order they appear in the load commands for the file
* they are in. This means the same ordinal may very well refer to different
* sections in different files.
*
* The n_value field for all symbol table entries (including N_STAB's) gets
* updated by the link editor based on the value of it's n_sect field and where
* the section n_sect references gets relocated. If the value of the n_sect
* field is NO_SECT then it's n_value field is not changed by the link editor.}
NO_SECT = 0; { symbol is not in any section }
MAX_SECT = 255; { 1 thru 255 inclusive }
{* Common symbols are represented by undefined (N_UNDF) external (N_EXT) types
* who's values (n_value) are non-zero. In which case the value of the n_value
* field is the size (in bytes) of the common symbol. The n_sect field is set
* to NO_SECT. The alignment of a common symbol may be set as a power of 2
* between 2^1 and 2^15 as part of the n_desc field using the macros below. If
* the alignment is not set (a value of zero) then natural alignment based on
* the size is used.}
{ ----- Process manually -----
#define GET_COMM_ALIGN(n_desc) (((n_desc) >> 8) & 0x0f)
#define SET_COMM_ALIGN(n_desc,align) \
(n_desc) = (((n_desc) & 0xf0ff) | (((align) & 0x0f) << 8))
}
{* To support the lazy binding of undefined symbols in the dynamic link-editor,
* the undefined symbols in the symbol table (the nlist structures) are marked
* with the indication if the undefined reference is a lazy reference or
* non-lazy reference. If both a non-lazy reference and a lazy reference is
* made to the same symbol the non-lazy reference takes precedence. A reference
* is lazy only when all references to that symbol are made through a symbol
* pointer in a lazy symbol pointer section.
*
* The implementation of marking nlist structures in the symbol table for
* undefined symbols will be to use some of the bits of the n_desc field as a
* reference type. The mask REFERENCE_TYPE will be applied to the n_desc field
* of an nlist structure for an undefined symbol to determine the type of
* undefined reference (lazy or non-lazy).
*
* The constants for the REFERENCE FLAGS are propagated to the reference table
* in a shared library file. In that case the constant for a defined symbol,
* REFERENCE_FLAG_DEFINED, is also used.}
{ Reference type bits of the n_desc field of undefined symbols }
REFERENCE_TYPE = $7;
{ types of references }
REFERENCE_FLAG_UNDEFINED_NON_LAZY = 0;
REFERENCE_FLAG_UNDEFINED_LAZY = 1;
REFERENCE_FLAG_DEFINED = 2;
REFERENCE_FLAG_PRIVATE_DEFINED = 3;
REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY = 4;
REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY = 5;
{* To simplify stripping of objects that use are used with the dynamic link
* editor, the static link editor marks the symbols defined an object that are
* referenced by a dynamicly bound object (dynamic shared libraries, bundles).
* With this marking strip knows not to strip these symbols.}
REFERENCED_DYNAMICALLY = $0010;
{* For images created by the static link editor with the -twolevel_namespace
* option in effect the flags field of the mach header is marked with
* MH_TWOLEVEL. And the binding of the undefined references of the image are
* determined by the static link editor. Which library an undefined symbol is
* bound to is recorded by the static linker in the high 8 bits of the n_desc
* field using the SET_LIBRARY_ORDINAL macro below. The ordinal recorded
* references the libraries listed in the Mach-O's LC_LOAD_DYLIB load commands
* in the order they appear in the headers. The library ordinals start from 1.
* For a dynamic library that is built as a two-level namespace image the
* undefined references from module defined in another use the same nlist struct
* an in that case SELF_LIBRARY_ORDINAL is used as the library ordinal. For
* defined symbols in all images they also must have the library ordinal set to
* SELF_LIBRARY_ORDINAL. The EXECUTABLE_ORDINAL refers to the executable
* image for references from plugins that refer to the executable that loads
* them.
*
* The DYNAMIC_LOOKUP_ORDINAL is for undefined symbols in a two-level namespace
* image that are looked up by the dynamic linker with flat namespace semantics.
* This ordinal was added as a feature in Mac OS X 10.3 by reducing the
* value of MAX_LIBRARY_ORDINAL by one. So it is legal for existing binaries
* or binaries built with older tools to have 0xfe (254) dynamic libraries. In
* this case the ordinal value 0xfe (254) must be treated as a library ordinal
* for compatibility.}
{ was #define dname(params) para_def_expr }
{ argument types are unknown }
{ return type might be wrong }
// function GET_LIBRARY_ORDINAL(n_desc : longint) : longint;
{ -- Process Manually ---
#define SET_LIBRARY_ORDINAL(n_desc,ordinal) \
(n_desc) = (((n_desc) & 0x00ff) | (((ordinal) & 0xff) << 8))
}
const
SELF_LIBRARY_ORDINAL = $0;
MAX_LIBRARY_ORDINAL = $fd;
DYNAMIC_LOOKUP_ORDINAL = $fe;
EXECUTABLE_ORDINAL = $ff;
{* The bit 0x0020 of the n_desc field is used for two non-overlapping purposes
* and has two different symbolic names, N_NO_DEAD_STRIP and N_DESC_DISCARDED. }
{* The N_NO_DEAD_STRIP bit of the n_desc field only ever appears in a
* relocatable .o file (MH_OBJECT filetype). And is used to indicate to the
* static link editor it is never to dead strip the symbol.}
N_NO_DEAD_STRIP = $0020; { symbol is not to be dead stripped }
{* The N_DESC_DISCARDED bit of the n_desc field never appears in linked image.
* But is used in very rare cases by the dynamic link editor to mark an in
* memory symbol as discared and longer used for linking. }
N_DESC_DISCARDED = $0020; { symbol is discarded }
{* The N_WEAK_REF bit of the n_desc field indicates to the dynamic linker that
* the undefined symbol is allowed to be missing and is to have the address of
* zero when missing. }
N_WEAK_REF = $0040; { symbol is weak referenced }
{* The N_WEAK_DEF bit of the n_desc field indicates to the static and dynamic
* linkers that the symbol definition is weak, allowing a non-weak symbol to
* also be used which causes the weak definition to be discared. Currently this
* is only supported for symbols in coalesed sections. }
N_WEAK_DEF = $0080; { coalesed symbol is a weak definition }
{* The N_REF_TO_WEAK bit of the n_desc field indicates to the dynamic linker
* that the undefined symbol should be resolved using flat namespace searching. }
N_REF_TO_WEAK = $0080; { reference to a weak symbol }
{* The N_ARM_THUMB_DEF bit of the n_desc field indicates that the symbol is
* a defintion of a Thumb function. }
N_ARM_THUMB_DEF = $0008; { symbol is a Thumb function (ARM) }
{* There are two known orders of table of contents for archives. The first is
* the order ranlib(1) originally produced and still produces without any
* options. This table of contents has the archive member name "__.SYMDEF"
* This order has the ranlib structures in the order the objects appear in the
* archive and the symbol names of those objects in the order of symbol table.
* The second know order is sorted by symbol name and is produced with the -s
* option to ranlib(1). This table of contents has the archive member name
* "__.SYMDEF SORTED" and many programs (notably the 1.0 version of ld(1) can't
* tell the difference between names because of the imbedded blank in the name
* and works with either table of contents). This second order is used by the
* post 1.0 link editor to produce faster linking. The original 1.0 version of
* ranlib(1) gets confused when it is run on a archive with the second type of
* table of contents because it and ar(1) which it uses use different ways to
* determined the member name (ar(1) treats all blanks in the name as
* significant and ranlib(1) only checks for the first one).}
const
SYMDEF = '__.SYMDEF';
SYMDEF_SORTED = '__.SYMDEF SORTED';
{
* Structure of the __.SYMDEF table of contents for an archive.
* __.SYMDEF begins with a long giving the size in bytes of the ranlib
* structures which immediately follow, and then continues with a string
* table consisting of a long giving the number of bytes of strings which
* follow and then the strings themselves. The ran_strx fields index the
* string table whose first byte is numbered 0.
}
type
ranlib = record
ran_un : record
case longint of
0 : ( ran_strx : uint32_t );
1 : ( ran_name : ^char );
end;
ran_off : uint32_t;
end;
type
{* Format of a relocation entry of a Mach-O file. Modified from the 4.3BSD
* format. The modifications from the original format were changing the value
* of the r_symbolnum field for "local" (r_extern == 0) relocation entries.
* This modification is required to support symbols in an arbitrary number of
* sections not just the three sections (text, data and bss) in a 4.3BSD file.
* Also the last 4 bits have had the r_type tag added to them. }
relocation_info = record
r_address : int32_t; { offset in the section to what is being relocated }
r_info : longint;
// r_symbolnum:24, {* symbol index if r_extern == 1 or section ordinal if r_extern == 0 *}
// r_pcrel:1; {* was relocated pc relative already *}
// r_length:2; {* 0=byte, 1=word, 2=long, 3=quad *}
// r_extern:1; {* does not include value of sym referenced *}
// r_type:4; {* if not 0, machine specific relocation type *}
end;
{ absolute relocation type for Mach-O files }
const
R_ABS = 0;
R_SCATTERED = $80000000; { mask to be applied to the r_address field }
{ of a relocation_info structure to tell that }
{ is is really a scattered_relocation_info }
{ stucture }
{
* The r_address is not really the address as it's name indicates but an offset.
* In 4.3BSD a.out objects this offset is from the start of the "segment" for
* which relocation entry is for (text or data). For Mach-O object files it is
* also an offset but from the start of the "section" for which the relocation
* entry is for. See comments in <mach-o/loader.h> about the r_address feild
* in images for used with the dynamic linker.
*
* In 4.3BSD a.out objects if r_extern is zero then r_symbolnum is an ordinal
* for the segment the symbol being relocated is in. These ordinals are the
* symbol types N_TEXT, N_DATA, N_BSS or N_ABS. In Mach-O object files these
* ordinals refer to the sections in the object file in the order their section
* structures appear in the headers of the object file they are in. The first
* section has the ordinal 1, the second 2, and so on. This means that the
* same ordinal in two different object files could refer to two different
* sections. And further could have still different ordinals when combined
* by the link-editor. The value R_ABS is used for relocation entries for
* absolute symbols which need no further relocation.
}
{
* For RISC machines some of the references are split across two instructions
* and the instruction does not contain the complete value of the reference.
* In these cases a second, or paired relocation entry, follows each of these
* relocation entries, using a PAIR r_type, which contains the other part of the
* reference not contained in the instruction. This other part is stored in the
* pair's r_address field. The exact number of bits of the other part of the
* reference store in the r_address field is dependent on the particular
* relocation type for the particular architecture.
}
{
* To make scattered loading by the link editor work correctly "local"
* relocation entries can't be used when the item to be relocated is the value
* of a symbol plus an offset (where the resulting expresion is outside the
* block the link editor is moving, a blocks are divided at symbol addresses).
* In this case. where the item is a symbol value plus offset, the link editor
* needs to know more than just the section the symbol was defined. What is
* needed is the actual value of the symbol without the offset so it can do the
* relocation correctly based on where the value of the symbol got relocated to
* not the value of the expression (with the offset added to the symbol value).
* So for the NeXT 2.0 release no "local" relocation entries are ever used when
* there is a non-zero offset added to a symbol. The "external" and "local"
* relocation entries remain unchanged.
*
* The implemention is quite messy given the compatibility with the existing
* relocation entry format. The ASSUMPTION is that a section will never be
* bigger than 2**24 - 1 (0x00ffffff or 16,777,215) bytes. This assumption
* allows the r_address (which is really an offset) to fit in 24 bits and high
* bit of the r_address field in the relocation_info structure to indicate
* it is really a scattered_relocation_info structure. Since these are only
* used in places where "local" relocation entries are used and not where
* "external" relocation entries are used the r_extern field has been removed.
*
* For scattered loading to work on a RISC machine where some of the references
* are split across two instructions the link editor needs to be assured that
* each reference has a unique 32 bit reference (that more than one reference is
* NOT sharing the same high 16 bits for example) so it move each referenced
* item independent of each other. Some compilers guarantees this but the
* compilers don't so scattered loading can be done on those that do guarantee
* this.
}
{
* The reason for the ifdef's of __BIG_ENDIAN__ and __LITTLE_ENDIAN__ are that
* when stattered relocation entries were added the mistake of using a mask
* against a structure that is made up of bit fields was used. To make this
* design work this structure must be laid out in memory the same way so the
* mask can be applied can check the same bit each time (r_scattered).
}
type
scattered_relocation_info = record
{$ifdef ENDIAN_BIG}
r_info : longint; { r_scattered:1, /* 1=scattered, 0=non-scattered (see above) */
r_pcrel:1, /* was relocated pc relative already */
r_length:2, /* 0=byte, 1=word, 2=long, 3=quad */
r_type:4, /* if not 0, machine specific relocation type */
r_address:24; /* offset in the section to what is being relocated */}
r_value : int32_t; {* the value the item to be relocated is refering to (without any offset added) *}
{$else}
r_value : int32_t;
r_info : longint; {* r_address:24, /* offset in the section to what is being relocated */
r_type:4, /* if not 0, machine specific relocation type */
r_length:2, /* 0=byte, 1=word, 2=long, 3=quad */
r_pcrel:1, /* was relocated pc relative already */
r_scattered:1; /* 1=scattered, 0=non-scattered (see above) */ *}
{$endif}
end;
{
* Relocation types used in a generic implementation. Relocation entries for
* normal things use the generic relocation as discribed above and their r_type
* is GENERIC_RELOC_VANILLA (a value of zero).
*
* Another type of generic relocation, GENERIC_RELOC_SECTDIFF, is to support
* the difference of two symbols defined in different sections. That is the
* expression "symbol1 - symbol2 + constant" is a relocatable expression when
* both symbols are defined in some section. For this type of relocation the
* both relocations entries are scattered relocation entries. The value of
* symbol1 is stored in the first relocation entry's r_value field and the
* value of symbol2 is stored in the pair's r_value field.
*
* A special case for a prebound lazy pointer is needed to beable to set the
* value of the lazy pointer back to its non-prebound state. This is done
* using the GENERIC_RELOC_PB_LA_PTR r_type. This is a scattered relocation
* entry where the r_value feild is the value of the lazy pointer not prebound.
}
const
GENERIC_RELOC_VANILLA = 0; { generic relocation as discribed above }
GENERIC_RELOC_PAIR = 1; { Only follows a GENERIC_RELOC_SECTDIFF }
GENERIC_RELOC_SECTDIFF = 2;
GENERIC_RELOC_PB_LA_PTR = 3; { prebound lazy pointer }
GENERIC_RELOC_LOCAL_SECTDIFF = 4;
{*
* Relocations for x86_64 are a bit different than for other architectures in
* Mach-O: Scattered relocations are not used. Almost all relocations produced
* by the compiler are external relocations. An external relocation has the
* r_extern bit set to 1 and the r_symbolnum field contains the symbol table
* index of the target label.
*
* When the assembler is generating relocations, if the target label is a local
* label (begins with 'L'), then the previous non-local label in the same
* section is used as the target of the external relocation. An addend is used
* with the distance from that non-local label to the target label. Only when
* there is no previous non-local label in the section is an internal
* relocation used.
*
* The addend (i.e. the 4 in _foo+4) is encoded in the instruction (Mach-O does
* not have RELA relocations). For PC-relative relocations, the addend is
* stored directly in the instruction. This is different from other Mach-O
* architectures, which encode the addend minus the current section offset.
*
* The relocation types are:
*
* X86_64_RELOC_UNSIGNED // for absolute addresses
* X86_64_RELOC_SIGNED // for signed 32-bit displacement
* X86_64_RELOC_BRANCH // a CALL/JMP instruction with 32-bit displacement
* X86_64_RELOC_GOT_LOAD // a MOVQ load of a GOT entry
* X86_64_RELOC_GOT // other GOT references
* X86_64_RELOC_SUBTRACTOR // must be followed by a X86_64_RELOC_UNSIGNED
*
* The following are sample assembly instructions, followed by the relocation
* and section content they generate in an object file:
*
* call _foo
* r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* E8 00 00 00 00
*
* call _foo+4
* r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* E8 04 00 00 00
*
* movq _foo@GOTPCREL(%rip), %rax
* r_type=X86_64_RELOC_GOT_LOAD, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* 48 8B 05 00 00 00 00
*
* pushq _foo@GOTPCREL(%rip)
* r_type=X86_64_RELOC_GOT, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* FF 35 00 00 00 00
*
* movl _foo(%rip), %eax
* r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* 8B 05 00 00 00 00
*
* movl _foo+4(%rip), %eax
* r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* 8B 05 04 00 00 00
*
* movb $0x12, _foo(%rip)
* r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* C6 05 FF FF FF FF 12
*
* movl $0x12345678, _foo(%rip)
* r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
* C7 05 FC FF FF FF 78 56 34 12
*
* .quad _foo
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
* 00 00 00 00 00 00 00 00
*
* .quad _foo+4
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
* 04 00 00 00 00 00 00 00
*
* .quad _foo - _bar
* r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
* 00 00 00 00 00 00 00 00
*
* .quad _foo - _bar + 4
* r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
* 04 00 00 00 00 00 00 00
*
* .long _foo - _bar
* r_type=X86_64_RELOC_SUBTRACTOR, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_bar
* r_type=X86_64_RELOC_UNSIGNED, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_foo
* 00 00 00 00
*
* lea L1(%rip), %rax
* r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_prev
* 48 8d 05 12 00 00 00
* // assumes _prev is the first non-local label 0x12 bytes before L1
*
* lea L0(%rip), %rax
* r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=0, r_pcrel=1, r_symbolnum=3
* 48 8d 05 56 00 00 00
* // assumes L0 is in third section, has an address of 0x00000056 in .o
* // file, and there is no previous non-local label
*
* .quad L1
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
* 12 00 00 00 00 00 00 00
* // assumes _prev is the first non-local label 0x12 bytes before L1
*
* .quad L0
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=0, r_pcrel=0, r_symbolnum=3
* 56 00 00 00 00 00 00 00
* // assumes L0 is in third section, has an address of 0x00000056 in .o
* // file, and there is no previous non-local label
*
* .quad _foo - .
* r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
* EE FF FF FF FF FF FF FF
* // assumes _prev is the first non-local label 0x12 bytes before this
* // .quad
*
* .quad _foo - L1
* r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
* EE FF FF FF FF FF FF FF
* // assumes _prev is the first non-local label 0x12 bytes before L1
*
* .quad L1 - _prev
* // No relocations. This is an assembly time constant.
* 12 00 00 00 00 00 00 00
* // assumes _prev is the first non-local label 0x12 bytes before L1
*
*
*
* In final linked images, there are only two valid relocation kinds:
*
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=1, r_symbolnum=sym_index
* This tells dyld to add the address of a symbol to a pointer sized (8-byte)
* piece of data (i.e on disk the 8-byte piece of data contains the addend). The
* r_symbolnum contains the index into the symbol table of the target symbol.
*
* r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=0, r_symbolnum=0
* This tells dyld to adjust the pointer sized (8-byte) piece of data by the amount
* the containing image was loaded from its base address (e.g. slide).
*
*}
const
X86_64_RELOC_UNSIGNED = 0; // for absolute addresses
X86_64_RELOC_SIGNED = 1; // for signed 32-bit displacement
X86_64_RELOC_BRANCH = 2; // a CALL/JMP instruction with 32-bit displacement
X86_64_RELOC_GOT_LOAD = 3; // a MOVQ load of a GOT entry
X86_64_RELOC_GOT = 4; // other GOT references
X86_64_RELOC_SUBTRACTOR = 5; // must be followed by a X86_64_RELOC_UNSIGNED
X86_64_RELOC_SIGNED_1 = 6; // for signed 32-bit displacement with a -1 addend
X86_64_RELOC_SIGNED_2 = 7; // for signed 32-bit displacement with a -2 addend
X86_64_RELOC_SIGNED_4 = 8; // for signed 32-bit displacement with a -4 addend
{* Relocation types used in the ppc implementation. Relocation entries for
* things other than instructions use the same generic relocation as discribed
* above and their r_type is RELOC_VANILLA. The rest of the relocation types
* are for instructions. Since they are for instructions the r_address field
* indicates the 32 bit instruction that the relocation is to be preformed on.
* The fields r_pcrel and r_length are ignored for non-RELOC_VANILLA r_types
* except for PPC_RELOC_BR14.
*
* For PPC_RELOC_BR14 if the r_length is the unused value 3, then the branch was
* statically predicted setting or clearing the Y-bit based on the sign of the
* displacement or the opcode. If this is the case the static linker must flip
* the value of the Y-bit if the sign of the displacement changes for non-branch
* always conditions.
}
const
PPC_RELOC_VANILLA = 0; { generic relocation as discribed above }
PPC_RELOC_PAIR = 1; { the second relocation entry of a pair }
PPC_RELOC_BR14 = 2; { 14 bit branch displacement (to a word address) }
PPC_RELOC_BR24 = 3; { 24 bit branch displacement (to a word address) }
PPC_RELOC_HI16 = 4; { a PAIR follows with the low half }
PPC_RELOC_LO16 = 5; { a PAIR follows with the high half }
PPC_RELOC_HA16 = 6; { Same as the RELOC_HI16 except the low 16 bits and the }
{ * high 16 bits are added together with the low 16 bits }
{ * sign extened first. This means if bit 15 of the low }
{ * 16 bits is set the high 16 bits stored in the }
{ * instruction will be adjusted. }
PPC_RELOC_LO14 = 7; { Same as the LO16 except that the low 2 bits are not }
{ * stored in the instruction and are always zero. This }
{ * is used in double word load/store instructions. }
PPC_RELOC_SECTDIFF = 8; { a PAIR follows with subtract symbol value }
PPC_RELOC_PB_LA_PTR = 9; { prebound lazy pointer }
PPC_RELOC_HI16_SECTDIFF = 10; { section difference forms of above. a PAIR }
PPC_RELOC_LO16_SECTDIFF = 11; { follows these with subtract symbol value }
PPC_RELOC_HA16_SECTDIFF = 12;
PPC_RELOC_JBSR = 13;
PPC_RELOC_LO14_SECTDIFF = 14;
PPC_RELOC_LOCAL_SECTDIFF = 15; { like PPC_RELOC_SECTDIFF, but the symbol referenced was local. }
{
* Symbolic debugger symbols. The comments give the conventional use for
*
* .stabs "n_name", n_type, n_sect, n_desc, n_value
*
* where n_type is the defined constant and not listed in the comment. Other
* fields not listed are zero. n_sect is the section ordinal the entry is
* refering to.
}
const
N_GSYM = $20; { global symbol: name,,NO_SECT,type,0 }
N_FNAME = $22; { procedure name (f77 kludge): name,,NO_SECT,0,0 }
N_FUN = $24; { procedure: name,,n_sect,linenumber,address }
N_STSYM = $26; { static symbol: name,,n_sect,type,address }
N_LCSYM = $28; { .lcomm symbol: name,,n_sect,type,address }
N_BNSYM = $2e; { begin nsect sym: 0,,n_sect,0,address }
N_OPT = $3c; { emitted with gcc2_compiled and in gcc source }
N_RSYM = $40; { register sym: name,,NO_SECT,type,register }
N_SLINE = $44; { src line: 0,,n_sect,linenumber,address }
N_ENSYM = $4e; { end nsect sym: 0,,n_sect,0,address }
N_SSYM = $60; { structure elt: name,,NO_SECT,type,struct_offset }
N_SO = $64; { source file name: name,,n_sect,0,address }
N_OSO = $66; { object file name: name,,0,0,st_mtime }
N_LSYM = $80; { local sym: name,,NO_SECT,type,offset }
N_BINCL = $82; { include file beginning: name,,NO_SECT,0,sum }
N_SOL = $84; { #included file name: name,,n_sect,0,address }
N_PARAMS = $86; { compiler parameters: name,,NO_SECT,0,0 }
N_VERSION = $88; { compiler version: name,,NO_SECT,0,0 }
N_OLEVEL = $8A; { compiler -O level: name,,NO_SECT,0,0 }
N_PSYM = $a0; { parameter: name,,NO_SECT,type,offset }
N_EINCL = $a2; { include file end: name,,NO_SECT,0,0 }
N_ENTRY = $a4; { alternate entry: name,,n_sect,linenumber,address }
N_LBRAC = $c0; { left bracket: 0,,NO_SECT,nesting level,address }
N_EXCL = $c2; { deleted include file: name,,NO_SECT,0,sum }
N_RBRAC = $e0; { right bracket: 0,,NO_SECT,nesting level,address }
N_BCOMM = $e2; { begin common: name,,NO_SECT,0,0 }
N_ECOMM = $e4; { end common: name,,n_sect,0,0 }
N_ECOML = $e8; { end common (local name): 0,,n_sect,0,address }
N_LENG = $fe; { second stab entry with length information }
{ * for the berkeley pascal compiler, pc(1): }
N_PC = $30; { global pascal symbol: name,,NO_SECT,subtype,line }
implementation
end.