--- /dev/null
+++ dyld/dyld-955/include/objc-shared-cache.h
@@ -0,0 +1,164 @@
+/* 
+ * Copyright (c) 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@
+ */
+
+/*
+ * objc-selopt.h
+ * Interface between libobjc and dyld 
+ * for selector uniquing in the dyld shared cache.
+ *
+ * When building the shared cache, dyld locates all selectors and selector 
+ * references in the cached images. It builds a perfect hash table out of 
+ * them and writes the table into the shared cache copy of libobjc.
+ * libobjc then uses that table as the builtin selector list.
+ *
+ * Versioning
+ * The table has a version number. dyld and objc can both ignore the table 
+ * if the other used the wrong version number.
+ *
+ * Completeness
+ * Not all libraries are in the shared cache. Libraries that are in the 
+ * shared cache and were optimized are specially marked. Libraries on 
+ * disk never include those marks.
+ *
+ * Coherency
+ * Libraries optimized in the shared cache can be replaced by unoptimized 
+ * copies from disk when loaded. The copy from disk is not marked and will 
+ * be fixed up by libobjc. The shared cache copy is still mapped into the 
+ * process, so the table can point to cstring data in that library's part 
+ * of the shared cache without trouble.
+ * 
+ * Atomicity
+ * dyld writes the table itself last. If dyld marks some metadata as 
+ * updated but then fails to write a table for some reason, libobjc 
+ * fixes up all metadata as if it were not marked.
+ */
+
+#ifndef _OBJC_SELOPT_H
+#define _OBJC_SELOPT_H
+
+#include <stdint.h>
+#include <stdlib.h>
+
+// Tell libobjc that this dyld is built for large caches
+// This really means the dyld SPIs are going to visit shared cache hash tables
+#define DYLD_LARGE_SHARED_CACHE_SUPPORT 1
+
+namespace objc {
+class SelectorHashTable;
+class ClassHashTable;
+class ProtocolHashTable;
+}
+
+namespace objc_opt {
+
+// Precomputed image list.
+struct objc_headeropt_ro_t;
+
+// Precomputed image list.
+struct objc_headeropt_rw_t;
+
+// Edit objc-sel-table.s if you change this value.
+// lldb and Symbolication read these structures. Inform them of any changes.
+enum { VERSION = 16 };
+
+// Values for objc_opt_t::flags
+enum : uint32_t {
+    IsProduction = (1 << 0),                // never set in development cache
+    NoMissingWeakSuperclasses = (1 << 1),   // set in development cache and customer
+    LargeSharedCache = (1 << 2),            // Shared cache was built with the new Large format
+};
+
+// Top-level optimization structure.
+// Edit objc-sel-table.s if you change this structure.
+struct alignas(alignof(uint64_t)) objc_opt_t {
+    uint32_t version;
+    uint32_t flags;
+    int32_t selopt_offset;
+    int32_t headeropt_ro_offset;
+    int32_t unused_clsopt_offset;
+    int32_t unused_protocolopt_offset; // This is now 0 as we've moved to the new protocolopt_offset
+    int32_t headeropt_rw_offset;
+    int32_t unused_protocolopt2_offset;
+    int32_t largeSharedCachesClassOffset;
+    int32_t largeSharedCachesProtocolOffset;
+    int64_t relativeMethodSelectorBaseAddressOffset; // Relative method list selectors are offsets from this address
+
+    const objc::SelectorHashTable* selectorOpt() const {
+        if (selopt_offset == 0) return NULL;
+        return (objc::SelectorHashTable *)((uint8_t *)this + selopt_offset);
+    }
+
+    struct objc_headeropt_ro_t* headeropt_ro() const {
+        if (headeropt_ro_offset == 0) return NULL;
+        return (struct objc_headeropt_ro_t *)((uint8_t *)this + headeropt_ro_offset);
+    }
+
+    void* oldClassOpt() const {
+        if (unused_clsopt_offset == 0) return NULL;
+        return (void *)((uint8_t *)this + unused_clsopt_offset);
+    }
+
+    void* protocolopt() const {
+        return NULL;
+    }
+
+    void* oldProtocolOpt2() const {
+        if (unused_protocolopt2_offset == 0) return NULL;
+        return (void *)((uint8_t *)this + unused_protocolopt2_offset);
+    }
+
+    struct objc_headeropt_rw_t* headeropt_rw() const {
+        if (headeropt_rw_offset == 0) return NULL;
+        return (struct objc_headeropt_rw_t *)((uint8_t *)this + headeropt_rw_offset);
+    }
+
+    const objc::ClassHashTable* classOpt() const {
+        if (largeSharedCachesClassOffset == 0) return NULL;
+        return (objc::ClassHashTable *)((uint8_t *)this + largeSharedCachesClassOffset);
+    }
+
+    const objc::ProtocolHashTable* protocolOpt() const {
+        if (largeSharedCachesProtocolOffset == 0) return NULL;
+        return (objc::ProtocolHashTable *)((uint8_t *)this + largeSharedCachesProtocolOffset);
+    }
+
+    const void* relativeMethodListsBaseAddress() const {
+        if (relativeMethodSelectorBaseAddressOffset == 0) return NULL;
+        return (const void*)((uint8_t *)this + relativeMethodSelectorBaseAddressOffset);
+    }
+};
+
+// sizeof(objc_opt_t) must be pointer-aligned
+static_assert(sizeof(objc_opt_t) % sizeof(void*) == 0);
+
+
+// List of offsets in libobjc that the shared cache optimization needs to use.
+template <typename T>
+struct objc_opt_pointerlist_tt {
+    T protocolClass;
+};
+typedef struct objc_opt_pointerlist_tt<uintptr_t> objc_opt_pointerlist_t;
+
+} // namespace objc_opt
+
+#endif