/* Copyright (C) 2003-2013 Runtime Revolution Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "prefix.h"

#include "globdefs.h"

#include "objdefs.h"

#include "parsedef.h"

#include "filedefs.h"

//#include "execpt.h"

#include "handler.h"

#include "scriptpt.h"

#include "variable.h"

#include "statemnt.h"

#include "deploy.h"

#if defined(_LINUX) || defined(_MACOSX)

#include <sys/stat.h>

#endif

////////////////////////////////////////////////////////////////////////////////

//

// This section contains definitions for the various structures needed to

// process the Mach-O executable format. These are taken from various mach headers

// In some cases the constant lists have been reduced since most are not relevant

// to what this module needs.

//

typedef int vm_prot_t;

/*

* Protection values, defined as bits within the vm_prot_t type

*/

#define VM_PROT_NONE ((vm_prot_t) 0x00)

#define VM_PROT_READ ((vm_prot_t) 0x01) /* read permission */

#define VM_PROT_WRITE ((vm_prot_t) 0x02) /* write permission */

#define VM_PROT_EXECUTE ((vm_prot_t) 0x04) /* execute permission */

/*

* The default protection for newly-created virtual memory

*/

#define VM_PROT_DEFAULT (VM_PROT_READ|VM_PROT_WRITE)

/*

* The maximum privileges possible, for parameter checking.

*/

#define VM_PROT_ALL (VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE)

typedef uint32_t cpu_type_t;

typedef uint32_t cpu_subtype_t;

/*

* Capability bits used in the definition of cpu_type.

*/

#define CPU_ARCH_MASK 0xff000000 /* mask for architecture bits */

#define CPU_ARCH_ABI64 0x01000000 /* 64 bit ABI */

/*

* Machine types known by all.

*/

#define CPU_TYPE_ANY ((cpu_type_t) -1)

#define CPU_TYPE_VAX ((cpu_type_t) 1)

/* skip ((cpu_type_t) 2) */

/* skip ((cpu_type_t) 3) */

/* skip ((cpu_type_t) 4) */

/* skip ((cpu_type_t) 5) */

#define CPU_TYPE_MC680x0 ((cpu_type_t) 6)

#define CPU_TYPE_X86 ((cpu_type_t) 7)

#define CPU_TYPE_I386 CPU_TYPE_X86 /* compatibility */

#define CPU_TYPE_X86_64 (CPU_TYPE_X86 | CPU_ARCH_ABI64)

/* skip CPU_TYPE_MIPS ((cpu_type_t) 8) */

/* skip ((cpu_type_t) 9) */

#define CPU_TYPE_MC98000 ((cpu_type_t) 10)

#define CPU_TYPE_HPPA ((cpu_type_t) 11)

#define CPU_TYPE_ARM ((cpu_type_t) 12)

#define CPU_TYPE_MC88000 ((cpu_type_t) 13)

#define CPU_TYPE_SPARC ((cpu_type_t) 14)

#define CPU_TYPE_I860 ((cpu_type_t) 15)

/* skip CPU_TYPE_ALPHA ((cpu_type_t) 16) */

/* skip ((cpu_type_t) 17) */

#define CPU_TYPE_POWERPC ((cpu_type_t) 18)

#define CPU_TYPE_POWERPC64 (CPU_TYPE_POWERPC | CPU_ARCH_ABI64)

/*

* Capability bits used in the definition of cpu_subtype.

*/

#define CPU_SUBTYPE_MASK 0xff000000 /* mask for feature flags */

#define CPU_SUBTYPE_LIB64 0x80000000 /* 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.

*/

#define CPU_SUBTYPE_MULTIPLE ((cpu_subtype_t) -1)

#define CPU_SUBTYPE_LITTLE_ENDIAN ((cpu_subtype_t) 0)

#define CPU_SUBTYPE_BIG_ENDIAN ((cpu_subtype_t) 1)

/*

* I386 subtypes

*/

#define CPU_SUBTYPE_INTEL(f, m) ((cpu_subtype_t) (f) + ((m) << 4))

#define CPU_SUBTYPE_I386_ALL CPU_SUBTYPE_INTEL(3, 0)

#define CPU_SUBTYPE_386 CPU_SUBTYPE_INTEL(3, 0)

#define CPU_SUBTYPE_486 CPU_SUBTYPE_INTEL(4, 0)

#define CPU_SUBTYPE_486SX CPU_SUBTYPE_INTEL(4, 8) // 8 << 4 = 128

#define CPU_SUBTYPE_586 CPU_SUBTYPE_INTEL(5, 0)

#define CPU_SUBTYPE_PENT CPU_SUBTYPE_INTEL(5, 0)

#define CPU_SUBTYPE_PENTPRO CPU_SUBTYPE_INTEL(6, 1)

#define CPU_SUBTYPE_PENTII_M3 CPU_SUBTYPE_INTEL(6, 3)

#define CPU_SUBTYPE_PENTII_M5 CPU_SUBTYPE_INTEL(6, 5)

#define CPU_SUBTYPE_CELERON CPU_SUBTYPE_INTEL(7, 6)

#define CPU_SUBTYPE_CELERON_MOBILE CPU_SUBTYPE_INTEL(7, 7)

#define CPU_SUBTYPE_PENTIUM_3 CPU_SUBTYPE_INTEL(8, 0)

#define CPU_SUBTYPE_PENTIUM_3_M CPU_SUBTYPE_INTEL(8, 1)

#define CPU_SUBTYPE_PENTIUM_3_XEON CPU_SUBTYPE_INTEL(8, 2)

#define CPU_SUBTYPE_PENTIUM_M CPU_SUBTYPE_INTEL(9, 0)

#define CPU_SUBTYPE_PENTIUM_4 CPU_SUBTYPE_INTEL(10, 0)

#define CPU_SUBTYPE_PENTIUM_4_M CPU_SUBTYPE_INTEL(10, 1)

#define CPU_SUBTYPE_ITANIUM CPU_SUBTYPE_INTEL(11, 0)

#define CPU_SUBTYPE_ITANIUM_2 CPU_SUBTYPE_INTEL(11, 1)

#define CPU_SUBTYPE_XEON CPU_SUBTYPE_INTEL(12, 0)

#define CPU_SUBTYPE_XEON_MP CPU_SUBTYPE_INTEL(12, 1)

#define CPU_SUBTYPE_INTEL_FAMILY(x) ((x) & 15)

#define CPU_SUBTYPE_INTEL_FAMILY_MAX 15

#define CPU_SUBTYPE_INTEL_MODEL(x) ((x) >> 4)

#define CPU_SUBTYPE_INTEL_MODEL_ALL 0

/*

* X86 subtypes.

*/

#define CPU_SUBTYPE_X86_ALL ((cpu_subtype_t)3)

#define CPU_SUBTYPE_X86_64_ALL ((cpu_subtype_t)3)

#define CPU_SUBTYPE_X86_ARCH1 ((cpu_subtype_t)4)

/*

* PowerPC subtypes

*/

#define CPU_SUBTYPE_POWERPC_ALL ((cpu_subtype_t) 0)

#define CPU_SUBTYPE_POWERPC_601 ((cpu_subtype_t) 1)

#define CPU_SUBTYPE_POWERPC_602 ((cpu_subtype_t) 2)

#define CPU_SUBTYPE_POWERPC_603 ((cpu_subtype_t) 3)

#define CPU_SUBTYPE_POWERPC_603e ((cpu_subtype_t) 4)

#define CPU_SUBTYPE_POWERPC_603ev ((cpu_subtype_t) 5)

#define CPU_SUBTYPE_POWERPC_604 ((cpu_subtype_t) 6)

#define CPU_SUBTYPE_POWERPC_604e ((cpu_subtype_t) 7)

#define CPU_SUBTYPE_POWERPC_620 ((cpu_subtype_t) 8)

#define CPU_SUBTYPE_POWERPC_750 ((cpu_subtype_t) 9)

#define CPU_SUBTYPE_POWERPC_7400 ((cpu_subtype_t) 10)

#define CPU_SUBTYPE_POWERPC_7450 ((cpu_subtype_t) 11)

#define CPU_SUBTYPE_POWERPC_970 ((cpu_subtype_t) 100)

#define FAT_MAGIC 0xcafebabe

#define FAT_CIGAM 0xbebafeca /* NXSwapLong(FAT_MAGIC) */

struct fat_header {

uint32_t magic; /* FAT_MAGIC */

uint32_t nfat_arch; /* number of structs that follow */

};

struct fat_arch {

cpu_type_t cputype; /* cpu specifier (int) */

cpu_subtype_t cpusubtype; /* machine specifier (int) */

uint32_t offset; /* file offset to this object file */

uint32_t size; /* size of this object file */

uint32_t align; /* alignment as a power of 2 */

};

/*

* The 32-bit mach header appears at the very beginning of the object file for

* 32-bit architectures.

*/

struct mach_header {

uint32_t magic; /* mach magic number identifier */

cpu_type_t cputype; /* cpu specifier */

cpu_subtype_t cpusubtype; /* machine specifier */

uint32_t filetype; /* type of file */

uint32_t ncmds; /* number of load commands */

uint32_t sizeofcmds; /* the size of all the load commands */

uint32_t flags; /* flags */

};

/* Constant for the magic field of the mach_header (32-bit architectures) */

#define MH_MAGIC 0xfeedface /* the mach magic number */

#define MH_CIGAM 0xcefaedfe /* NXSwapInt(MH_MAGIC) */

/*

* 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

*/

#define MH_OBJECT 0x1 /* relocatable object file */

#define MH_EXECUTE 0x2 /* demand paged executable file */

#define MH_FVMLIB 0x3 /* fixed VM shared library file */

#define MH_CORE 0x4 /* core file */

#define MH_PRELOAD 0x5 /* preloaded executable file */

#define MH_DYLIB 0x6 /* dynamically bound shared library */

#define MH_DYLINKER 0x7 /* dynamic link editor */

#define MH_BUNDLE 0x8 /* dynamically bound bundle file */

#define MH_DYLIB_STUB 0x9 /* shared library stub for static */

/* linking only, no section contents */

#define MH_DSYM 0xa /* companion file with only debug */

/* sections */

/*

* 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.

*/

struct load_command {

uint32_t cmd; /* type of load command */

uint32_t cmdsize; /* total size of command in bytes */

};

/*

* 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.

*/

#define LC_REQ_DYLD 0x80000000

/* Constants for the cmd field of all load commands, the type */

#define LC_SEGMENT 0x1 /* segment of this file to be mapped */

#define LC_SYMTAB 0x2 /* link-edit stab symbol table info */

#define LC_SYMSEG 0x3 /* link-edit gdb symbol table info (obsolete) */

#define LC_THREAD 0x4 /* thread */

#define LC_UNIXTHREAD 0x5 /* unix thread (includes a stack) */

#define LC_LOADFVMLIB 0x6 /* load a specified fixed VM shared library */

#define LC_IDFVMLIB 0x7 /* fixed VM shared library identification */

#define LC_IDENT 0x8 /* object identification info (obsolete) */

#define LC_FVMFILE 0x9 /* fixed VM file inclusion (internal use) */

#define LC_PREPAGE 0xa /* prepage command (internal use) */

#define LC_DYSYMTAB 0xb /* dynamic link-edit symbol table info */

#define LC_LOAD_DYLIB 0xc /* load a dynamically linked shared library */

#define LC_ID_DYLIB 0xd /* dynamically linked shared lib ident */

#define LC_LOAD_DYLINKER 0xe /* load a dynamic linker */

#define LC_ID_DYLINKER 0xf /* dynamic linker identification */

#define LC_PREBOUND_DYLIB 0x10 /* modules prebound for a dynamically */

/* linked shared library */

#define LC_ROUTINES 0x11 /* image routines */

#define LC_SUB_FRAMEWORK 0x12 /* sub framework */

#define LC_SUB_UMBRELLA 0x13 /* sub umbrella */

#define LC_SUB_CLIENT 0x14 /* sub client */

#define LC_SUB_LIBRARY 0x15 /* sub library */

#define LC_TWOLEVEL_HINTS 0x16 /* two-level namespace lookup hints */

#define LC_PREBIND_CKSUM 0x17 /* prebind checksum */

/*

* load a dynamically linked shared library that is allowed to be missing

* (all symbols are weak imported).

*/

#define LC_LOAD_WEAK_DYLIB (0x18 | LC_REQ_DYLD)

#define LC_SEGMENT_64 0x19 /* 64-bit segment of this file to be

mapped */

#define LC_ROUTINES_64 0x1a /* 64-bit image routines */

#define LC_UUID 0x1b /* the uuid */

#define LC_RPATH (0x1c | LC_REQ_DYLD) /* runpath additions */

#define LC_CODE_SIGNATURE 0x1d /* local of code signature */

#define LC_SEGMENT_SPLIT_INFO 0x1e /* local of info to split segments */

#define LC_REEXPORT_DYLIB (0x1f | LC_REQ_DYLD) /* load and re-export dylib */

#define LC_LAZY_LOAD_DYLIB 0x20 /* delay load of dylib until first use */

#define LC_ENCRYPTION_INFO 0x21 /* encrypted segment information */

#define LC_VERSION_MIN_MACOSX 0x24 /* build for MacOSX min OS version */

#define LC_VERSION_MIN_IPHONEOS 0x25 /* build for iPhoneOS min OS version */

#define LC_FUNCTION_STARTS 0x26

#define LC_DATA_IN_CODE 0x29

#define LC_DYLIB_CODE_SIGN_DRS 0x2B

#define LC_DYLD_INFO 0x22

#define LC_DYLD_INFO_ONLY 0x80000022

#define LC_SOURCE_VERSION 0x2A

/*

* 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.

*/

union lc_str {

uint32_t offset; /* offset to the string */

#ifndef __LP64__

char *ptr; /* pointer to the string */

#endif

};

/*

* 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.

*/

struct dylib {

union lc_str name; /* library's path name */

uint32_t timestamp; /* library's build time stamp */

uint32_t current_version; /* library's current version number */

uint32_t compatibility_version; /* library's compatibility vers number*/

};

/*

* 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.

*/

struct dylib_command {

uint32_t cmd; /* LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB,

LC_REEXPORT_DYLIB */

uint32_t cmdsize; /* includes pathname string */

struct dylib dylib; /* the library identification */

};

/*

* 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.

*/

struct segment_command { /* for 32-bit architectures */

uint32_t cmd; /* LC_SEGMENT */

uint32_t cmdsize; /* includes sizeof section structs */

char segname[16]; /* segment name */

uint32_t vmaddr; /* memory address of this segment */

uint32_t vmsize; /* memory size of this segment */

uint32_t fileoff; /* file offset of this segment */

uint32_t filesize; /* amount to map from the file */

vm_prot_t maxprot; /* maximum VM protection */

vm_prot_t initprot; /* initial VM protection */

uint32_t nsects; /* number of sections in segment */

uint32_t flags; /* flags */

};

/*

* 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>.

*/

struct section { /* for 32-bit architectures */

char sectname[16]; /* name of this section */

char segname[16]; /* segment this section goes in */

uint32_t addr; /* memory address of this section */

uint32_t size; /* size in bytes of this section */

uint32_t offset; /* file offset of this section */

uint32_t align; /* section alignment (power of 2) */

uint32_t reloff; /* file offset of relocation entries */

uint32_t nreloc; /* number of relocation entries */

uint32_t flags; /* flags (section type and attributes)*/

uint32_t reserved1; /* reserved (for offset or index) */

uint32_t reserved2; /* reserved (for count or sizeof) */

};

/*

* 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).

*/

#define SECTION_TYPE 0x000000ff /* 256 section types */

#define SECTION_ATTRIBUTES 0xffffff00 /* 24 section attributes */

/* Constants for the type of a section */

#define S_REGULAR 0x0 /* regular section */

#define S_ZEROFILL 0x1 /* zero fill on demand section */

#define S_CSTRING_LITERALS 0x2 /* section with only literal C strings*/

#define S_4BYTE_LITERALS 0x3 /* section with only 4 byte literals */

#define S_8BYTE_LITERALS 0x4 /* section with only 8 byte literals */

#define S_LITERAL_POINTERS 0x5 /* section with only pointers to */

/* literals */

/*

* 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>.

*/

struct symtab_command {

uint32_t cmd; /* LC_SYMTAB */

uint32_t cmdsize; /* sizeof(struct symtab_command) */

uint32_t symoff; /* symbol table offset */

uint32_t nsyms; /* number of symbol table entries */

uint32_t stroff; /* string table offset */

uint32_t strsize; /* string table size in bytes */

};

struct nlist {

int32_t n_strx;

uint8_t n_type;

uint8_t n_sect;

int16_t n_desc;

uint32_t n_value;

};

#define N_UNDF 0x00 /* undefined */

#define N_ABS 0x02 /* absolute address */

#define N_TEXT 0x04 /* text segment */

#define N_DATA 0x06 /* data segment */

#define N_BSS 0x08 /* bss segment */

#define N_COMM 0x12 /* common reference */

#define N_FN 0x1e /* file name */

#define N_EXT 0x01 /* external (global) bit, OR'ed in */

#define N_TYPE 0x1e /* mask for all the type bits */

#define N_FORMAT "%08x" /* namelist value format; XXX */

#define N_STAB 0x0e0 /* mask for debugger symbols -- stab(5) */

/*

* 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.

*/

struct dysymtab_command {

uint32_t cmd; /* LC_DYSYMTAB */

uint32_t cmdsize; /* 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).

*/

uint32_t ilocalsym; /* index to local symbols */

uint32_t nlocalsym; /* number of local symbols */

uint32_t iextdefsym;/* index to externally defined symbols */

uint32_t nextdefsym;/* number of externally defined symbols */

uint32_t iundefsym; /* index to undefined symbols */

uint32_t nundefsym; /* 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.

*/

uint32_t tocoff; /* file offset to table of contents */

uint32_t ntoc; /* 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.

*/

uint32_t modtaboff; /* file offset to module table */

uint32_t nmodtab; /* 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.

*/

uint32_t extrefsymoff; /* offset to referenced symbol table */

uint32_t nextrefsyms; /* 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.

*/

uint32_t indirectsymoff; /* file offset to the indirect symbol table */

uint32_t nindirectsyms; /* 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).

*/

uint32_t extreloff; /* offset to external relocation entries */

uint32_t nextrel; /* 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).

*/

uint32_t locreloff; /* offset to local relocation entries */

uint32_t nlocrel; /* number of local relocation entries */

};

/*

* 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.

*/

#define INDIRECT_SYMBOL_LOCAL 0x80000000

#define INDIRECT_SYMBOL_ABS 0x40000000

/* a table of contents entry */

struct dylib_table_of_contents {

uint32_t symbol_index; /* the defined external symbol

(index into the symbol table) */

uint32_t module_index; /* index into the module table this symbol

is defined in */

};

/* a module table entry */

struct dylib_module {

uint32_t module_name; /* the module name (index into string table) */

uint32_t iextdefsym; /* index into externally defined symbols */

uint32_t nextdefsym; /* number of externally defined symbols */

uint32_t irefsym; /* index into reference symbol table */

uint32_t nrefsym; /* number of reference symbol table entries */

uint32_t ilocalsym; /* index into symbols for local symbols */

uint32_t nlocalsym; /* number of local symbols */

uint32_t iextrel; /* index into external relocation entries */

uint32_t nextrel; /* number of external relocation entries */

uint32_t iinit_iterm; /* low 16 bits are the index into the init

section, high 16 bits are the index into

the term section */

uint32_t ninit_nterm; /* low 16 bits are the number of init section

entries, high 16 bits are the number of

term section entries */

uint32_t /* for this module address of the start of */

objc_module_info_addr; /* the (__OBJC,__module_info) section */

uint32_t /* for this module size of */

objc_module_info_size; /* the (__OBJC,__module_info) section */

};

/*

* 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.

*/

struct dylib_reference {

uint32_t isym:24, /* index into the symbol table */

flags:8; /* flags to indicate the type of reference */

};

/*

* 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.

*/

struct relocation_info {

int32_t r_address; /* offset in the section to what is being

relocated */

uint32_t 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 */

};

#define R_ABS 0 /* absolute relocation type for Mach-O files */

/*

* The twolevel_hints_command contains the offset and number of hints in the

* two-level namespace lookup hints table.

*/

struct twolevel_hints_command {

uint32_t cmd; /* LC_TWOLEVEL_HINTS */

uint32_t cmdsize; /* sizeof(struct twolevel_hints_command) */

uint32_t offset; /* offset to the hint table */

uint32_t nhints; /* number of hints in the hint table */

};

struct linkedit_data_command

{

uint32_t cmd;

uint32_t cmdsize;

uint32_t dataoff;

uint32_t datasize;

};

struct dyld_info_command

{

uint32_t cmd;

uint32_t cmdsize;

uint32_t rebase_off;

uint32_t rebase_size;

uint32_t bind_off;

uint32_t bind_size;

uint32_t weak_bind_off;

uint32_t weak_bind_size;

uint32_t lazy_bind_off;

uint32_t lazy_bind_size;

uint32_t export_off;

uint32_t export_size;

};

////////////////////////////////////////////////////////////////////////////////

static void swap_uint32(bool p_to_network, uint32_t& x)

{

MCDeployByteSwapRecord(p_to_network, "l", &x, sizeof(uint32_t));

}

static void swap_fat_header(bool p_to_network, fat_header& x)

{

MCDeployByteSwapRecord(p_to_network, "ll", &x, sizeof(fat_header));

}

static void swap_fat_arch(bool p_to_network, fat_arch& x)

{

MCDeployByteSwapRecord(p_to_network, "lllll", &x, sizeof(fat_arch));

}

static void swap_mach_header(bool p_to_network, mach_header& x)

{

MCDeployByteSwapRecord(p_to_network, "lllllll", &x, sizeof(mach_header));

}

static void swap_load_command_hdr(bool p_to_network, load_command& x)

{

MCDeployByteSwapRecord(p_to_network, "ll", &x, sizeof(load_command));

}

static void swap_segment_command(bool p_to_network, segment_command& x)

{

MCDeployByteSwapRecord(p_to_network, "llbbbbbbbbbbbbbbbbllllllll", &x, sizeof(segment_command));

for(uint32_t i = 0; i < x . nsects; i++)

{

section *t_section;

t_section = (section *)(&x + 1);

MCDeployByteSwapRecord(p_to_network, "lllllllll", &t_section -> addr, sizeof(section) - 32);

}

}

static void unswap_segment_command(bool p_to_network, segment_command& x)

{

for(uint32_t i = 0; i < x . nsects; i++)

{

section *t_section;

t_section = (section *)(&x + 1);

MCDeployByteSwapRecord(p_to_network, "lllllllll", &t_section -> addr, sizeof(section) - 32);

}

MCDeployByteSwapRecord(p_to_network, "llbbbbbbbbbbbbbbbbllllllll", &x, sizeof(segment_command));

}

static void swap_twolevel_hints_command(bool p_to_network, twolevel_hints_command& x)

{

MCDeployByteSwapRecord(p_to_network, "llll", &x, sizeof(twolevel_hints_command));

}

static void swap_symtab_command(bool p_to_network, symtab_command& x)

{

MCDeployByteSwapRecord(p_to_network, "llllll", &x, sizeof(symtab_command));

}

static void swap_dysymtab_command(bool p_to_network, dysymtab_command& x)

{

MCDeployByteSwapRecord(p_to_network, "llllllllllllllllllll", &x, sizeof(dysymtab_command));

}

static void swap_dylib_command(bool p_to_network, dylib_command& x)

{

MCDeployByteSwapRecord(p_to_network, "llllll", &x, sizeof(dylib_command));

}

static void swap_nlist(bool p_to_network, nlist& x)

{

MCDeployByteSwapRecord(p_to_network, "lbbsl", &x, sizeof(nlist));

}

static void swap_relocation_info(bool p_to_network, relocation_info& x)

{

MCDeployByteSwapRecord(p_to_network, "ll", &x, sizeof(relocation_info));

}

static void swap_load_command(bool p_to_network, uint32_t p_type, load_command* x)

{

switch(p_type)

{

case LC_SEGMENT:

if (p_type != x -> cmd)

swap_segment_command(p_to_network, *(segment_command *)x);

else

unswap_segment_command(p_to_network, *(segment_command *)x);

break;

case LC_TWOLEVEL_HINTS:

swap_twolevel_hints_command(p_to_network, *(twolevel_hints_command *)x);

break;

case LC_SYMTAB:

swap_symtab_command(p_to_network, *(symtab_command *)x);

break;

case LC_DYSYMTAB:

swap_dysymtab_command(p_to_network, *(dysymtab_command *)x);

break;

case LC_LOAD_DYLIB:

swap_dylib_command(p_to_network, *(dylib_command *)x);

break;

case LC_UUID:

case LC_THREAD:

case LC_UNIXTHREAD:

case LC_LOAD_DYLINKER:

swap_load_command_hdr(p_to_network, *x);

break;

default:

swap_load_command_hdr(p_to_network, *x);

break;

}

}

static void relocate_segment_command(segment_command *x, int32_t p_file_delta, int32_t p_address_delta)

{

x -> vmaddr += p_address_delta;

x -> fileoff += p_file_delta;

for(uint32_t i = 0; i < x -> nsects; i++)

{

section *t_section;

t_section = (section *)(x + 1);

t_section -> addr += p_address_delta;

t_section -> offset += p_file_delta;

t_section -> reloff += p_file_delta;

}

}

static void relocate_twolevel_hints_command(twolevel_hints_command *x, int32_t p_file_delta, int32_t p_address_delta)

{

x -> offset += p_file_delta;

}

static void relocate_symtab_command(symtab_command *x, int32_t p_file_delta, int32_t p_address_delta)

{

if (x -> symoff != 0)

x -> symoff += p_file_delta;

if (x -> stroff != 0)

x -> stroff += p_file_delta;

}

static void relocate_dysymtab_command(dysymtab_command *x, int32_t p_file_delta, int32_t p_address_delta)

{

if (x -> tocoff != 0)

x -> tocoff += p_file_delta;

if (x -> modtaboff != 0)

x -> modtaboff += p_file_delta;

if (x -> extrefsymoff != 0)

x -> extrefsymoff += p_file_delta;

if (x -> indirectsymoff != 0)

x -> indirectsymoff += p_file_delta;

if (x -> extreloff != 0)

x -> extreloff += p_file_delta;

if (x -> locreloff != 0)

x -> locreloff += p_file_delta;

}

static void relocate_code_signature_command(linkedit_data_command *x, int32_t p_file_delta, int32_t p_address_delta)

{

x -> dataoff += p_file_delta;

}

static void relocate_dyld_info_command(dyld_info_command *x, int32_t p_file_delta, int32_t p_address_delta)

{

if (x -> rebase_off != 0)

x -> rebase_off += p_file_delta;

if (x -> bind_off != 0)

x -> bind_off += p_file_delta;

if (x -> weak_bind_off != 0)

x -> weak_bind_off += p_file_delta;

if (x -> lazy_bind_off != 0)

x -> lazy_bind_off += p_file_delta;

if (x -> export_off != 0)

x -> export_off += p_file_delta;

}

static void relocate_function_starts_command(linkedit_data_command *x, int32_t p_file_delta, int32_t p_address_delta)

{

x -> dataoff += p_file_delta;

}

/*static void relocate_encryption_info_command(encryption_info_command *x, int32_t p_file_data, int32_t p_address_delta)

{

}*/

////////////////////////////////////////////////////////////////////////////////

typedef bool (*MCDeployValidateHeaderCallback)(const MCDeployParameters& params, mach_header& header, load_command **commands);

static bool MCDeployToMacOSXReadHeader(bool p_big_endian, MCDeployFileRef p_engine, uint32_t p_offset, mach_header& r_header, load_command**& r_commands)

{

// Read the mach-o header.

if (!MCDeployFileReadAt(p_engine, &r_header, sizeof(mach_header), p_offset))

return MCDeployThrow(kMCDeployErrorMacOSXNoHeader);

swap_mach_header(p_big_endian, r_header);

// Validate the header

if (r_header . magic != MH_MAGIC ||

(r_header . filetype != MH_EXECUTE && r_header . filetype != MH_BUNDLE && r_header . filetype != MH_OBJECT))

return MCDeployThrow(kMCDeployErrorMacOSXBadHeader);

// Allocate memory for the load commands

r_commands = new load_command *[r_header . ncmds];

if (r_commands == NULL)

return MCDeployThrow(kMCDeployErrorNoMemory);

memset(r_commands, 0, sizeof(load_command *) * r_header . ncmds);

// And read them in

uint32_t t_offset;

t_offset = p_offset + sizeof(mach_header);

for(uint32_t i = 0; i < r_header . ncmds; i++)

{

// First read the command header

load_command t_command;

if (!MCDeployFileReadAt(p_engine, &t_command, sizeof(load_command), t_offset))

return MCDeployThrow(kMCDeployErrorMacOSXBadCommand);

swap_load_command_hdr(p_big_endian, t_command);

// Now allocate memory for the full command record

r_commands[i] = (load_command *)malloc(t_command . cmdsize);