[apple/dyld.git] / dyld3 / LaunchCacheFormat.h

/*
 * Copyright (c) 2017 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@
 */


#ifndef LaunchCacheFormat_h
#define LaunchCacheFormat_h


#include <stdint.h>
#include <assert.h>
#include <uuid/uuid.h>
#include <mach/mach.h>

#include "LaunchCache.h"


namespace dyld3 {
namespace launch_cache {
namespace binary_format {


// bump this number each time binary format changes
enum  { kFormatVersion = 8 };

union VIS_HIDDEN ImageRef {
    ImageRef() : val(0xFFFFFFFF) { }
                ImageRef(uint8_t kind, uint32_t groupNum, uint32_t indexInGroup) : _linkKind(kind), _groupNum(groupNum), _indexInGroup(indexInGroup) {
                    assert(groupNum < (1 << 18));
                    assert(indexInGroup < (1 << 12));
                }
    uint8_t     kind()  const { return _linkKind; }
    uint32_t    groupNum() const { return _groupNum; }
    uint32_t    indexInGroup() const { return _indexInGroup; }
    uint16_t    value() const { return val; }
    void        clearKind()  { _linkKind = 0; }
    
    bool operator==(const ImageRef& rhs) const {
        return (val == rhs.val);
    }
    bool operator!=(const ImageRef& rhs) const {
        return (val != rhs.val);
    }
    static ImageRef weakImportMissing();
    static ImageRef makeEmptyImageRef() { return ImageRef(); }

private:
    ImageRef(uint32_t v) : val(v) { }

    uint32_t     val;
    struct {
        uint32_t _linkKind       :   2,     // Image::LinkKind
                 _groupNum       :  18,     // 0 => cached dylib group, 1 => other dylib group, 2 => main closure, etc
                 _indexInGroup   :  12;     // max 64K images in group
    };
};


// In disk based images, all segments are multiples of page size
// This struct just tracks the size (disk and vm) of each segment.
// This is compact for most every image which have contiguous segments.
// If the image does not have contiguous segments (rare), an extra
// DiskSegment is inserted with the paddingNotSeg bit set.
struct DiskSegment
{
    uint64_t    filePageCount   : 30,
                vmPageCount     : 30,
                permissions     : 3,
                paddingNotSeg   : 1;
};


// In cache DATA_DIRTY is not page aligned or sized
// This struct allows segments with any alignment and up to 256MB in size
struct DyldCacheSegment
{
    uint64_t    cacheOffset : 32,
                size        : 28,
                permissions : 4;
};

// When an Image is built on the device, the mtime and inode are recorded.
// When built off device, the first 16 bytes of SHA1 of CodeDirectory is recorded.
union FileInfo
{
    struct {
        uint64_t mtime;
        uint64_t inode;
    } statInfo;
    struct {
        uint8_t  bytes[16];
    } cdHash16;
};

struct Image
{
    uint32_t            isDiskImage      : 1,       // images are DiskImage - not Image
                        isInvalid        : 1,       // an error occurred creating the info for this image
                        has16KBpages     : 1,
                        hasTextRelocs    : 1,
                        hasObjC          : 1,
                        mayHavePlusLoads : 1,
                        isEncrypted      : 1,       // image is DSMOS or FairPlay encrypted
                        hasWeakDefs      : 1,
                        neverUnload      : 1,
                        cwdSameAsThis    : 1,       // dylibs use file system relative paths, cwd must be main's dir
                        isPlatformBinary : 1,       // part of OS - can be loaded into LV process
                        isBundle         : 1,
                        overridableDylib : 1,       // only applicable to group 0
                        padding          : 7,
                        maxLoadCount     : 12;
    int32_t             groupOffset;                // back pointer to containing ImageGroup (from start of Image)
    uint32_t            pathPoolOffset;
    uint32_t            pathHash;
    FileInfo            fileInfo;
    uuid_t              uuid;
    uint16_t            dependentsArrayStartIndex;
    uint16_t            dependentsArrayCount;
    uint16_t            segmentsArrayStartIndex;
    uint16_t            segmentsArrayCount;
    uint16_t            initBeforeArrayStartIndex;
    uint16_t            initBeforeArrayCount;
    uint16_t            initOffsetsArrayStartIndex;
    uint16_t            initOffsetsArrayCount;
    uint16_t            dofOffsetsArrayStartIndex;
    uint16_t            dofOffsetsArrayCount;
};

// an image in the dyld shared cache
struct CachedImage : public Image
{
    uint32_t            patchStartIndex;
    uint32_t            patchCount;
};

// an image not in the dyld shared cache (loaded from disk at runtime)
struct DiskImage : public Image
{
    uint32_t            totalVmPages;
    uint32_t            sliceOffsetIn4K;
    uint32_t            codeSignFileOffset;
    uint32_t            codeSignFileSize;
    uint32_t            fixupsPoolOffset      : 28,    // offset in ImageGroup's pool for AllFixupsBySegment
                        fixupsPoolSegCount    : 4;     // count of segments in AllFixupsBySegment for this image
    uint32_t            fairPlayTextPageCount : 28,
                        fairPlayTextStartPage : 4;
    uint32_t            targetsArrayStartIndex;         // index in ImageGroup's pool of OrdinalEntry
    uint32_t            targetsArrayCount;
};


// if an Image has an alias (symlink to it), the Image does not record the alias, but the ImageGroup does
struct AliasEntry
{
    uint32_t    aliasHash;
    uint32_t    imageIndexInGroup;
    uint32_t    aliasOffsetInStringPool;
};

// each DiskImage points to an array of these, one per segment with fixups
struct AllFixupsBySegment
{
    uint32_t    segIndex    : 4,
                offset      : 28;    // from start of AllFixupsBySegment to this seg's SegmentFixupsByPage
};


// This struct is suitable for passing into kernel when kernel supports fixups on page-in.
struct SegmentFixupsByPage
{
    uint32_t    size;                // of this struct, including fixup opcodes
    uint32_t    pageSize;            // 0x1000 or 0x4000
    uint32_t    pageCount;
    uint32_t    pageInfoOffsets[1];  // array size is pageCount
    // each page info is a FixUpOpcode[]
};

enum class FixUpOpcode : uint8_t {
      done            = 0x00,
//    apply           = 0x10,
      rebase32        = 0x10,    // add32 slide at current pageOffset, increment pageOffset by 4
      rebase64        = 0x11,    // add64 slide at current pageOffset, increment pageOffset by 8
      bind32          = 0x12,    // set 32-bit ordinal value at current pageOffset, increment pageOffset by 4
      bind64          = 0x13,    // set 64-bit ordinal value at current pageOffset, increment pageOffset by 8
      rebaseText32    = 0x14,    // add32 slide at current text pageOffset, increment pageOffset by 4
      bindText32      = 0x15,    // set 32-bit ordinal value at current text pageOffset, increment pageOffset by 4
      bindTextRel32   = 0x16,    // set delta to 32-bit ordinal value at current text pageOffset, increment pageOffset by 4 (i386 CALL to dylib)
      bindImportJmp32 = 0x17,    // set delta to 32-bit ordinal value at current text pageOffset, increment pageOffset by 4 (i386 JMP to dylib)
//    fixupChain64    = 0x18,    // current page offset is start of a chain of locations to fix up
//    adjPageOffset   = 0x20,
      setPageOffset   = 0x20,    // low 4-bits is amount to increment (1 to 15).  If zero, then add next ULEB (note: can set offset for unaligned pointer)
      incPageOffset   = 0x30,    // low 4-bits *4 is amount to increment (4 to 60).  If zero, then add next ULEB * 4
//    adjOrdinal      = 0x40,
      setOrdinal      = 0x40,    // low 4-bits is ordinal (1-15).  If zero, then ordinal is next ULEB
      incOrdinal      = 0x50,    // low 4-bits is ordinal inc amount (1-15).  If zero, then ordinal is next ULEB
    repeat            = 0x60     // low 5-bits is how many next bytes to repeat.  next ULEB is repeat count
};

// If a closure uses DYLD_LIBRARY_PATH to override an OS dylib, there is an
// ImageRefOverride entry to redirect uses of the OS dylib.
struct ImageRefOverride
{
    ImageRef standardDylib;
    ImageRef overrideDylib;
};

// If a closure interposes on, or has a dylib that overrides, something in the dyld shared cache,
// then closure's ImageGroup contains an array of these
struct DyldCacheOverride
{
    uint64_t    patchTableIndex     : 24,       // index into PatchTable array of group 0
                imageIndex          : 8,        // index in this group (2) of what to replace with
                imageOffset         : 32;       // offset within image to override something in cache
};


// The ImageGroup for the dyld shared cache dylibs contains and array of these
// with one entry for each symbol in a cached dylib that is used by some other cached dylib.
struct PatchTable
{
    uint32_t    targetCacheOffset;      // delta from the base address of the cache to the address of the symbol to patch
    uint32_t    offsetsStartIndex;      // index into the PatchOffset array of first location to patch, last offset has low bit set
};

struct PatchOffset
{
    uint32_t    last             : 1,
                hasAddend        : 1,
                dataRegionOffset : 30;
};

struct ImageGroup
{
    uint32_t        imagesEntrySize         : 8,
                    dylibsExpectedOnDisk    : 1,
                    imageFileInfoIsCdHash   : 1,
                    padding                 : 14;
    uint32_t        groupNum;
    uint32_t        imagesPoolCount;
    uint32_t        imagesPoolOffset;           // offset to array of Image or DiskImage
    uint32_t        imageAliasCount;
    uint32_t        imageAliasOffset;           // offset to array of AliasEntry
    uint32_t        segmentsPoolCount;
    uint32_t        segmentsPoolOffset;         // offset to array of Segment or DyldCacheSegment
    uint32_t        dependentsPoolCount;
    uint32_t        dependentsPoolOffset;       // offset to array of ImageRef
    uint32_t        intializerOffsetPoolCount;
    uint32_t        intializerOffsetPoolOffset; // offset to array of uint32_t
    uint32_t        intializerListPoolCount;
    uint32_t        intializerListPoolOffset;   // offset to array of ImageRef
    uint32_t        targetsPoolCount;
    uint32_t        targetsOffset;              // offset to array of TargetSymbolValue
    uint32_t        fixupsPoolSize;
    uint32_t        fixupsOffset;               // offset to list of AllFixupsBySegment
    uint32_t        cachePatchTableCount;
    uint32_t        cachePatchTableOffset;      // offset to array of PatchTable (used only in group 0)
    uint32_t        cachePatchOffsetsCount;
    uint32_t        cachePatchOffsetsOffset;    // offset to array of PatchOffset cache offsets (used only in group 0)
    uint32_t        symbolOverrideTableCount;
    uint32_t        symbolOverrideTableOffset;  // offset to array of DyldCacheOverride (used only in group 2)
    uint32_t        imageOverrideTableCount;
    uint32_t        imageOverrideTableOffset;   // offset to array of ImageRefOverride (used only in group 2)
    uint32_t        dofOffsetPoolCount;
    uint32_t        dofOffsetPoolOffset;        // offset to array of uint32_t
    uint32_t        indirectGroupNumPoolCount;
    uint32_t        indirectGroupNumPoolOffset; // offset to array of uint32_t
    uint32_t        stringsPoolSize;
    uint32_t        stringsPoolOffset;
    // Image array
    // Alias array
    // Segment array
    // ImageRef array
    // Initializer offsets array
    // Initializer ImageRef array
    // TargetSymbolValue array
    // AllFixupsBySegment pool
    // PatchTable array
    // PatchOffset array
    // DyldCacheOverride array
    // ImageRefOverride array
    // string pool
    // DOF offsets array
};


struct Closure
{
    enum { magicV1 = 0x31646c6e };

    uint32_t        magic;
    uint32_t        usesCRT                  : 1,
                    isRestricted             : 1,
                    usesLibraryValidation    : 1,
                    padding                  : 29;
    uint32_t        missingFileComponentsOffset;    // offset to array of 16-bit string pool offset of path components
    uint32_t        dyldEnvVarsOffset;
    uint32_t        dyldEnvVarsCount;
    uint32_t        stringPoolOffset;
    uint32_t        stringPoolSize;
    ImageRef        libSystemRef;
    ImageRef        libDyldRef;
    uint32_t        libdyldVectorOffset;
    uint32_t        mainExecutableIndexInGroup;
    uint32_t        mainExecutableEntryOffset;
    uint32_t        initialImageCount;
    uuid_t          dyldCacheUUID;                // all zero if this closure is embedded in a dyld cache
    uint8_t         mainExecutableCdHash[20];     // or UUID if not code signed
    ImageGroup      group;
    // MissingFile array
    // env vars array
    // string pool
};


} // namespace binary_format

} // namespace launch_cache
} // namespace dyld


#endif // LaunchCacheFormat_h
Commit	Line	Data
10b92d3b A	1	/*
	2	* Copyright (c) 2017 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24
	25
	26	#ifndef LaunchCacheFormat_h
	27	#define LaunchCacheFormat_h
	28
	29
	30	#include <stdint.h>
	31	#include <assert.h>
	32	#include <uuid/uuid.h>
	33	#include <mach/mach.h>
	34
	35	#include "LaunchCache.h"
	36
	37
	38	namespace dyld3 {
	39	namespace launch_cache {
	40	namespace binary_format {
	41
	42
	43	// bump this number each time binary format changes
	44	enum { kFormatVersion = 8 };
	45
	46	union VIS_HIDDEN ImageRef {
	47	ImageRef() : val(0xFFFFFFFF) { }
	48	ImageRef(uint8_t kind, uint32_t groupNum, uint32_t indexInGroup) : _linkKind(kind), _groupNum(groupNum), _indexInGroup(indexInGroup) {
	49	assert(groupNum < (1 << 18));
	50	assert(indexInGroup < (1 << 12));
	51	}
	52	uint8_t kind() const { return _linkKind; }
	53	uint32_t groupNum() const { return _groupNum; }
	54	uint32_t indexInGroup() const { return _indexInGroup; }
	55	uint16_t value() const { return val; }
	56	void clearKind() { _linkKind = 0; }
	57
	58	bool operator==(const ImageRef& rhs) const {
	59	return (val == rhs.val);
	60	}
	61	bool operator!=(const ImageRef& rhs) const {
	62	return (val != rhs.val);
	63	}
	64	static ImageRef weakImportMissing();
65	static ImageRef makeEmptyImageRef() { return ImageRef(); }
66
67	private:
68	ImageRef(uint32_t v) : val(v) { }
69
70	uint32_t val;
71	struct {
72	uint32_t _linkKind : 2, // Image::LinkKind
73	_groupNum : 18, // 0 => cached dylib group, 1 => other dylib group, 2 => main closure, etc
74	_indexInGroup : 12; // max 64K images in group
75	};
76	};
77
78
79
80
81	// In disk based images, all segments are multiples of page size
82	// This struct just tracks the size (disk and vm) of each segment.
83	// This is compact for most every image which have contiguous segments.
84	// If the image does not have contiguous segments (rare), an extra
85	// DiskSegment is inserted with the paddingNotSeg bit set.
86	struct DiskSegment
87	{
88	uint64_t filePageCount : 30,
89	vmPageCount : 30,
90	permissions : 3,
91	paddingNotSeg : 1;
92	};
93
94
95	// In cache DATA_DIRTY is not page aligned or sized
96	// This struct allows segments with any alignment and up to 256MB in size
97	struct DyldCacheSegment
98	{
99	uint64_t cacheOffset : 32,
100	size : 28,
101	permissions : 4;
102	};
103
104	// When an Image is built on the device, the mtime and inode are recorded.
105	// When built off device, the first 16 bytes of SHA1 of CodeDirectory is recorded.
106	union FileInfo
107	{
108	struct {
109	uint64_t mtime;
110	uint64_t inode;
111	} statInfo;
112	struct {
113	uint8_t bytes[16];
114	} cdHash16;
115	};
116
117	struct Image
118	{
119	uint32_t isDiskImage : 1, // images are DiskImage - not Image
120	isInvalid : 1, // an error occurred creating the info for this image
121	has16KBpages : 1,
122	hasTextRelocs : 1,
123	hasObjC : 1,
124	mayHavePlusLoads : 1,
125	isEncrypted : 1, // image is DSMOS or FairPlay encrypted
126	hasWeakDefs : 1,
127	neverUnload : 1,
128	cwdSameAsThis : 1, // dylibs use file system relative paths, cwd must be main's dir
129	isPlatformBinary : 1, // part of OS - can be loaded into LV process
130	isBundle : 1,
131	overridableDylib : 1, // only applicable to group 0
132	padding : 7,
133	maxLoadCount : 12;
134	int32_t groupOffset; // back pointer to containing ImageGroup (from start of Image)
135	uint32_t pathPoolOffset;
136	uint32_t pathHash;
137	FileInfo fileInfo;
138	uuid_t uuid;
139	uint16_t dependentsArrayStartIndex;
140	uint16_t dependentsArrayCount;
141	uint16_t segmentsArrayStartIndex;
142	uint16_t segmentsArrayCount;
143	uint16_t initBeforeArrayStartIndex;
144	uint16_t initBeforeArrayCount;
145	uint16_t initOffsetsArrayStartIndex;
146	uint16_t initOffsetsArrayCount;
147	uint16_t dofOffsetsArrayStartIndex;
148	uint16_t dofOffsetsArrayCount;
149	};
150
151	// an image in the dyld shared cache
152	struct CachedImage : public Image
153	{
154	uint32_t patchStartIndex;
155	uint32_t patchCount;
156	};
157
158	// an image not in the dyld shared cache (loaded from disk at runtime)
159	struct DiskImage : public Image
160	{
161	uint32_t totalVmPages;
162	uint32_t sliceOffsetIn4K;
163	uint32_t codeSignFileOffset;
164	uint32_t codeSignFileSize;
165	uint32_t fixupsPoolOffset : 28, // offset in ImageGroup's pool for AllFixupsBySegment
166	fixupsPoolSegCount : 4; // count of segments in AllFixupsBySegment for this image
167	uint32_t fairPlayTextPageCount : 28,
168	fairPlayTextStartPage : 4;
169	uint32_t targetsArrayStartIndex; // index in ImageGroup's pool of OrdinalEntry
170	uint32_t targetsArrayCount;
171	};
172
173
174	// if an Image has an alias (symlink to it), the Image does not record the alias, but the ImageGroup does
175	struct AliasEntry
176	{
177	uint32_t aliasHash;
178	uint32_t imageIndexInGroup;
179	uint32_t aliasOffsetInStringPool;
180	};
181
182	// each DiskImage points to an array of these, one per segment with fixups
183	struct AllFixupsBySegment
184	{
185	uint32_t segIndex : 4,
186	offset : 28; // from start of AllFixupsBySegment to this seg's SegmentFixupsByPage
187	};
188
189
190	// This struct is suitable for passing into kernel when kernel supports fixups on page-in.
191	struct SegmentFixupsByPage
192	{
193	uint32_t size; // of this struct, including fixup opcodes
194	uint32_t pageSize; // 0x1000 or 0x4000
195	uint32_t pageCount;
196	uint32_t pageInfoOffsets[1]; // array size is pageCount
197	// each page info is a FixUpOpcode[]
198	};
199
200	enum class FixUpOpcode : uint8_t {
201	done = 0x00,
202	// apply = 0x10,
203	rebase32 = 0x10, // add32 slide at current pageOffset, increment pageOffset by 4
204	rebase64 = 0x11, // add64 slide at current pageOffset, increment pageOffset by 8
205	bind32 = 0x12, // set 32-bit ordinal value at current pageOffset, increment pageOffset by 4
206	bind64 = 0x13, // set 64-bit ordinal value at current pageOffset, increment pageOffset by 8
207	rebaseText32 = 0x14, // add32 slide at current text pageOffset, increment pageOffset by 4
208	bindText32 = 0x15, // set 32-bit ordinal value at current text pageOffset, increment pageOffset by 4
209	bindTextRel32 = 0x16, // set delta to 32-bit ordinal value at current text pageOffset, increment pageOffset by 4 (i386 CALL to dylib)
210	bindImportJmp32 = 0x17, // set delta to 32-bit ordinal value at current text pageOffset, increment pageOffset by 4 (i386 JMP to dylib)
211	// fixupChain64 = 0x18, // current page offset is start of a chain of locations to fix up
212	// adjPageOffset = 0x20,
213	setPageOffset = 0x20, // low 4-bits is amount to increment (1 to 15). If zero, then add next ULEB (note: can set offset for unaligned pointer)
214	incPageOffset = 0x30, // low 4-bits 4 is amount to increment (4 to 60). If zero, then add next ULEB 4
215	// adjOrdinal = 0x40,
216	setOrdinal = 0x40, // low 4-bits is ordinal (1-15). If zero, then ordinal is next ULEB
217	incOrdinal = 0x50, // low 4-bits is ordinal inc amount (1-15). If zero, then ordinal is next ULEB
218	repeat = 0x60 // low 5-bits is how many next bytes to repeat. next ULEB is repeat count
219	};
220
221	// If a closure uses DYLD_LIBRARY_PATH to override an OS dylib, there is an
222	// ImageRefOverride entry to redirect uses of the OS dylib.
223	struct ImageRefOverride
224	{
225	ImageRef standardDylib;
226	ImageRef overrideDylib;
227	};
228
229	// If a closure interposes on, or has a dylib that overrides, something in the dyld shared cache,
230	// then closure's ImageGroup contains an array of these
231	struct DyldCacheOverride
232	{
233	uint64_t patchTableIndex : 24, // index into PatchTable array of group 0
234	imageIndex : 8, // index in this group (2) of what to replace with
235	imageOffset : 32; // offset within image to override something in cache
236	};
237
238
239	// The ImageGroup for the dyld shared cache dylibs contains and array of these
240	// with one entry for each symbol in a cached dylib that is used by some other cached dylib.
241	struct PatchTable
242	{
243	uint32_t targetCacheOffset; // delta from the base address of the cache to the address of the symbol to patch
244	uint32_t offsetsStartIndex; // index into the PatchOffset array of first location to patch, last offset has low bit set
245	};
246
247	struct PatchOffset
248	{
249	uint32_t last : 1,
250	hasAddend : 1,
251	dataRegionOffset : 30;
252	};
253
254	struct ImageGroup
255	{
256	uint32_t imagesEntrySize : 8,
257	dylibsExpectedOnDisk : 1,
258	imageFileInfoIsCdHash : 1,
259	padding : 14;
260	uint32_t groupNum;
261	uint32_t imagesPoolCount;
262	uint32_t imagesPoolOffset; // offset to array of Image or DiskImage
263	uint32_t imageAliasCount;
264	uint32_t imageAliasOffset; // offset to array of AliasEntry
265	uint32_t segmentsPoolCount;
266	uint32_t segmentsPoolOffset; // offset to array of Segment or DyldCacheSegment
267	uint32_t dependentsPoolCount;
268	uint32_t dependentsPoolOffset; // offset to array of ImageRef
269	uint32_t intializerOffsetPoolCount;
270	uint32_t intializerOffsetPoolOffset; // offset to array of uint32_t
271	uint32_t intializerListPoolCount;
272	uint32_t intializerListPoolOffset; // offset to array of ImageRef
273	uint32_t targetsPoolCount;
274	uint32_t targetsOffset; // offset to array of TargetSymbolValue
275	uint32_t fixupsPoolSize;
276	uint32_t fixupsOffset; // offset to list of AllFixupsBySegment
277	uint32_t cachePatchTableCount;
278	uint32_t cachePatchTableOffset; // offset to array of PatchTable (used only in group 0)
279	uint32_t cachePatchOffsetsCount;
280	uint32_t cachePatchOffsetsOffset; // offset to array of PatchOffset cache offsets (used only in group 0)
281	uint32_t symbolOverrideTableCount;
282	uint32_t symbolOverrideTableOffset; // offset to array of DyldCacheOverride (used only in group 2)
283	uint32_t imageOverrideTableCount;
284	uint32_t imageOverrideTableOffset; // offset to array of ImageRefOverride (used only in group 2)
285	uint32_t dofOffsetPoolCount;
286	uint32_t dofOffsetPoolOffset; // offset to array of uint32_t
287	uint32_t indirectGroupNumPoolCount;
288	uint32_t indirectGroupNumPoolOffset; // offset to array of uint32_t
289	uint32_t stringsPoolSize;
290	uint32_t stringsPoolOffset;
291	// Image array
292	// Alias array
293	// Segment array
294	// ImageRef array
295	// Initializer offsets array
296	// Initializer ImageRef array
297	// TargetSymbolValue array
298	// AllFixupsBySegment pool
299	// PatchTable array
300	// PatchOffset array
301	// DyldCacheOverride array
302	// ImageRefOverride array
303	// string pool
304	// DOF offsets array
305	};
306
307
308	struct Closure
309	{
310	enum { magicV1 = 0x31646c6e };
311
312	uint32_t magic;
313	uint32_t usesCRT : 1,
314	isRestricted : 1,
315	usesLibraryValidation : 1,
316	padding : 29;
317	uint32_t missingFileComponentsOffset; // offset to array of 16-bit string pool offset of path components
318	uint32_t dyldEnvVarsOffset;
319	uint32_t dyldEnvVarsCount;
320	uint32_t stringPoolOffset;
321	uint32_t stringPoolSize;
322	ImageRef libSystemRef;
323	ImageRef libDyldRef;
324	uint32_t libdyldVectorOffset;
325	uint32_t mainExecutableIndexInGroup;
326	uint32_t mainExecutableEntryOffset;
327	uint32_t initialImageCount;
328	uuid_t dyldCacheUUID; // all zero if this closure is embedded in a dyld cache
329	uint8_t mainExecutableCdHash[20]; // or UUID if not code signed
330	ImageGroup group;
331	// MissingFile array
332	// env vars array
333	// string pool
334	};
335
336
337
338	} // namespace binary_format
339
340	} // namespace launch_cache
341	} // namespace dyld
342
343
344	#endif // LaunchCacheFormat_h
345
346