dyld3/Closure.h

   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 #ifndef Closures_h
  26 #define Closures_h
  27
  28
  29 #include <stdint.h>
  30 #include <assert.h>
  31 #include <uuid/uuid.h>
  32 #include <mach/mach.h>
  33 #include <mach-o/loader.h>
  34
  35 #include "Diagnostics.h"
  36 #include "Array.h"
  37 #include "MachOLoaded.h"
  38 #include "SupportedArchs.h"
  39
  40 namespace objc_opt {
  41 struct objc_opt_t;
  42 }
  43
  44 namespace dyld3 {
  45 namespace closure {
  46
  47
  48
  49 // bump this number each time binary format changes
  50 enum  { kFormatVersion = 10 };
  51
  52
  53 typedef uint32_t ImageNum;
  54
  55 const ImageNum kFirstDyldCacheImageNum      = 0x00000001;
  56 const ImageNum kLastDyldCacheImageNum       = 0x00000FFF;
  57 const ImageNum kFirstOtherOSImageNum        = 0x00001001;
  58 const ImageNum kLastOtherOSImageNum         = 0x00001FFF;
  59 const ImageNum kFirstLaunchClosureImageNum  = 0x00002000;
  60 const ImageNum kMissingWeakLinkedImage      = 0x0FFFFFFF;
  61
  62 class ObjCSelectorOpt;
  63 class ObjCClassOpt;
  64 class ObjCClassDuplicatesOpt;
  65
  66 //
  67 //  Generic typed range of bytes (similar to load commands)
  68 //  Must be 4-byte aligned
  69 //
  70 struct VIS_HIDDEN TypedBytes
  71 {
  72     enum class Type : uint32_t {
  73         // containers which have an overall length and TypedBytes inside their content
  74         launchClosure    =  1, // contains TypedBytes of closure attributes including imageArray
  75         imageArray       =  2, // sizeof(ImageArray) + sizeof(uint32_t)*count + size of all images
  76         image            =  3, // contains TypedBytes of image attributes
  77         dlopenClosure    =  4, // contains TypedBytes of closure attributes including imageArray
  78
  79         // attributes for Images
  80         imageFlags       =  7, // sizeof(Image::Flags)
  81         pathWithHash     =  8, // len = uint32_t + length path + 1, use multiple entries for aliases
  82         fileInodeAndTime =  9, // sizeof(FileInfo)
  83         cdHash           = 10, // 20, use multiple entries on watchOS for all hashes
  84         uuid             = 11, // 16
  85         mappingInfo      = 12, // sizeof(MappingInfo)
  86         diskSegment      = 13, // sizeof(DiskSegment) * count
  87         cacheSegment     = 14, // sizeof(DyldCacheSegment) * count
  88         dependents       = 15, // sizeof(LinkedImage) * count
  89         initOffsets      = 16, // sizeof(uint32_t) * count
  90         dofOffsets       = 17, // sizeof(uint32_t) * count
  91         codeSignLoc      = 18, // sizeof(CodeSignatureLocation)
  92         fairPlayLoc      = 19, // sizeof(FairPlayRange)
  93         rebaseFixups     = 20, // sizeof(RebasePattern) * count
  94         bindFixups       = 21, // sizeof(BindPattern) * count
  95         cachePatchInfo   = 22, // deprecated
  96         textFixups       = 23, // sizeof(TextFixupPattern) * count
  97         imageOverride    = 24, // sizeof(ImageNum)
  98         initBefores      = 25, // sizeof(ImageNum) * count
  99         initsSection     = 26, // sizeof(InitializerSectionRange)
 100         chainedFixupsTargets = 27, // sizeof(ResolvedSymbolTarget) * count
 101         termOffsets      = 28, // sizeof(uint32_t) * count
 102         chainedStartsOffset = 29, // sizeof(uint64_t)
 103         objcFixups       = 30,   // sizeof(ResolvedSymbolTarget) + (sizeof(uint32_t) * 2) + (sizeof(ProtocolISAFixup) * count) + (sizeof(SelectorReferenceFixup) * count)
 104
 105         // attributes for Closures (launch or dlopen)
 106         closureFlags            = 32,  // sizeof(Closure::Flags)
 107         dyldCacheUUID           = 33,  // 16
 108         missingFiles            = 34,
 109         envVar                  = 35,  // "DYLD_BLAH=stuff"
 110         topImage                = 36,  // sizeof(ImageNum)
 111         libDyldEntry            = 37,  // sizeof(ResolvedSymbolTarget)
 112         libSystemNum            = 38,  // sizeof(ImageNum)
 113         bootUUID                = 39,  // c-string 40
 114         mainEntry               = 40,  // sizeof(ResolvedSymbolTarget)
 115         startEntry              = 41,  // sizeof(ResolvedSymbolTarget)     // used by programs built with crt1.o
 116         cacheOverrides          = 42,  // sizeof(PatchEntry) * count       // used if process uses interposing or roots (cached dylib overrides)
 117         interposeTuples         = 43,  // sizeof(InterposingTuple) * count
 118         existingFiles           = 44,  // uint64_t + (SkippedFiles * count)
 119         selectorTable           = 45,  // uint32_t + (sizeof(ObjCSelectorImage) * count) + hashTable size
 120         classTable              = 46,  // (3 * uint32_t) + (sizeof(ObjCClassImage) * count) + classHashTable size + protocolHashTable size
 121         warning                 = 47,  // len = uint32_t + length path + 1, use one entry per warning
 122         duplicateClassesTable   = 48, // duplicateClassesHashTable
 123    };
 124
 125     Type         type          : 8;
 126     uint32_t     payloadLength : 24;
 127
 128     const void*     payload() const;
 129     void*           payload();
 130 };
 131
 132 static_assert(sizeof(TypedBytes) == 4, "Wrong size for TypedBytes");
 133
 134
 135 //
 136 //  A TypedBytes which is a bag of other TypedBytes
 137 //
 138 struct VIS_HIDDEN ContainerTypedBytes : TypedBytes
 139 {
 140     void                forEachAttribute(void (^callback)(const TypedBytes* typedBytes, bool& stop)) const;
 141     void                forEachAttributePayload(Type requestedType, void (^handler)(const void* payload, uint32_t size, bool& stop)) const;
 142     const void*         findAttributePayload(Type requestedType, uint32_t* payloadSize=nullptr) const;
 143 private:
 144     const TypedBytes*   first() const;
 145     const TypedBytes*   next(const TypedBytes*) const;
 146 };
 147
 148
 149 //
 150 //  Information about a mach-o file
 151 //
 152 struct VIS_HIDDEN Image : ContainerTypedBytes
 153 {
 154     enum class LinkKind { regular=0, weak=1, upward=2, reExport=3 };
 155
 156     size_t              size() const;
 157     ImageNum            imageNum() const;
 158     bool                representsImageNum(ImageNum num) const;  // imageNum() or isOverrideOfDyldCacheImage()
 159     uint32_t            maxLoadCount() const;
 160     const char*         path() const;
 161     const char*         leafName() const;
 162     bool                getUuid(uuid_t) const;
 163     bool                isInvalid() const;
 164     bool                inDyldCache() const;
 165     bool                hasObjC() const;
 166     bool                hasInitializers() const;
 167     bool                hasPrecomputedObjC() const;
 168     bool                hasTerminators() const;
 169     bool                hasReadOnlyData() const;
 170     bool                hasChainedFixups() const;
 171     bool                isBundle() const;
 172     bool                isDylib() const;
 173     bool                isExecutable() const;
 174     bool                hasWeakDefs() const;
 175     bool                mayHavePlusLoads() const;
 176     bool                is64() const;
 177     bool                neverUnload() const;
 178     bool                cwdMustBeThisDir() const;
 179     bool                isPlatformBinary() const;
 180     bool                overridableDylib() const;
 181     bool                hasFileModTimeAndInode(uint64_t& inode, uint64_t& mTime) const;
 182     void                forEachCDHash(void (^handler)(const uint8_t cdHash[20], bool& stop)) const;
 183     void                forEachAlias(void (^handler)(const char* aliasPath, bool& stop)) const;
 184     void                forEachDependentImage(void (^handler)(uint32_t dependentIndex, LinkKind kind, ImageNum imageNum, bool& stop)) const;
 185     ImageNum            dependentImageNum(uint32_t depIndex) const;
 186     bool                containsAddress(const void* addr, const void* imageLoadAddress, uint8_t* permissions=nullptr) const;
 187     bool                forEachInitializerSection(void (^handler)(uint32_t sectionOffset, uint32_t sectionSize)) const;
 188     void                forEachInitializer(const void* imageLoadAddress, void (^handler)(const void* initializer)) const;
 189     void                forEachTerminator(const void* imageLoadAddress, void (^handler)(const void* terminator)) const;
 190     void                forEachImageToInitBefore(void (^handler)(ImageNum imageToInit, bool& stop)) const;
 191     void                forEachDOF(const void* imageLoadAddress, void (^handler)(const void* initializer)) const;
 192     bool                hasPathWithHash(const char* path, uint32_t hash) const;
 193     bool                isOverrideOfDyldCacheImage(ImageNum& cacheImageNum) const;
 194     uint64_t            textSize() const;
 195
 196         union ResolvedSymbolTarget
 197     {
 198         enum Kinds { kindRebase, kindSharedCache, kindImage, kindAbsolute };
 199
 200         struct Rebase {
 201             uint64_t    kind            :  2,       // kindRebase
 202                         unused          : 62;       // all zeros
 203         };
 204         struct SharedCache {
 205             uint64_t    kind            :  2;       // kindSharedCache
 206             int64_t     offset          : 62;
 207         };
 208         struct Image {
 209             uint64_t    kind            :  2,       // kindImage
 210                         imageNum        : 22;       // ImageNum
 211             int64_t     offset          : 40;
 212         };
 213         struct Absolute {
 214             uint64_t    kind            :  2,       // kindAbsolute
 215                         value           : 62;       // sign extended
 216         };
 217         Rebase          rebase;
 218         SharedCache     sharedCache;
 219         Image           image;
 220         Absolute        absolute;
 221         uint64_t        raw;
 222
 223         bool operator==(const ResolvedSymbolTarget& rhs) const {
 224             return (raw == rhs.raw);
 225         }
 226         bool operator!=(const ResolvedSymbolTarget& rhs) const {
 227             return (raw != rhs.raw);
 228         }
 229      };
 230      static_assert(sizeof(ResolvedSymbolTarget) == 8);
 231
 232
 233     // ObjC optimisations
 234     struct ObjCImageOffset {
 235         union {
 236             uint32_t raw = 0;
 237             struct {
 238                 uint32_t imageIndex  : 8;
 239                 uint32_t imageOffset : 24;
 240             };
 241         };
 242
 243         enum : uint32_t {
 244             // The unused value so that we have a sentinel in our hash table
 245             sentinelValue = 0xFFFFFFFF,
 246
 247             // The maximum image index
 248             maximumImageIndex = (1U << 8) - 1,
 249
 250             // The maximum offset from the start of the strings section
 251             maximumOffset = (1U << 24) - 1
 252         };
 253     };
 254
 255     struct ObjCClassNameImageOffset {
 256         union {
 257             uint32_t raw = 0;
 258             struct {
 259                 uint32_t classNameImageIndex  : 8;
 260                 uint32_t classNameImageOffset : 24;
 261             };
 262         };
 263
 264         enum : uint32_t {
 265             // The unused value so that we have a sentinel in our hash table
 266             sentinelValue = 0xFFFFFFFF,
 267
 268             // The maximum image index
 269             maximumImageIndex = (1U << 8) - 1,
 270
 271             // The maximum offset from the start of the strings section
 272             maximumOffset = (1U << 24) - 1
 273         };
 274     };
 275
 276     struct ObjCClassImageOffset {
 277         union {
 278             uint32_t raw = 0;
 279             struct {
 280                 uint32_t imageIndex         : 8;
 281                 uint32_t imageOffset        : 23;
 282                 uint32_t isDuplicate        : 1; // == 0
 283             } classData;
 284             struct {
 285                 uint32_t count              : 8;
 286                 uint32_t index              : 23;
 287                 uint32_t isDuplicate        : 1; // == 1
 288             } duplicateData;
 289         };
 290
 291         enum : uint32_t {
 292             // The unused value so that we have a sentinel in our hash table
 293             sentinelValue = 0xFFFFFFFF,
 294
 295             // The maximum image index
 296             maximumImageIndex = (1U << 8) - 1,
 297
 298             // The maximum offset from the start of the class data section
 299             maximumOffset = (1U << 23) - 1
 300         };
 301     };
 302
 303     static_assert(sizeof(ObjCClassImageOffset) == 4, "Invalid size");
 304
 305     static_assert(ObjCClassNameImageOffset::maximumImageIndex == ObjCClassImageOffset::maximumImageIndex , "Invalid indices");
 306
 307     struct ObjCDuplicateClass {
 308         union {
 309             uint32_t raw = 0;
 310             struct {
 311                 uint32_t sharedCacheClassOptIndex : 20;
 312                 uint32_t sharedCacheClassDuplicateIndex : 12;
 313             };
 314         };
 315
 316         enum : uint32_t {
 317             // The unused value so that we have a sentinel in our hash table
 318             sentinelValue = 0xFFFFFFFF
 319         };
 320     };
 321
 322     static_assert(sizeof(ObjCDuplicateClass) == 4, "Invalid size");
 323
 324     struct ObjCSelectorImage {
 325         ImageNum imageNum;
 326         uint32_t offset;
 327     };
 328
 329     struct ObjCClassImage {
 330         ImageNum imageNum;
 331         uint32_t offsetOfClassNames;
 332         uint32_t offsetOfClasses;
 333     };
 334
 335     typedef MachOLoaded::ChainedFixupPointerOnDisk ChainedFixupPointerOnDisk;
 336
 337     // the following are only valid if inDyldCache() returns true
 338     uint32_t            cacheOffset() const;
 339     uint32_t            patchStartIndex() const;
 340     uint32_t            patchCount() const;
 341     void                forEachCacheSegment(void (^handler)(uint32_t segIndex, uint64_t vmOffset, uint64_t vmSize, uint8_t permissions, bool& stop)) const;
 342
 343
 344     // the following are only valid if inDyldCache() returns false
 345     uint64_t            vmSizeToMap() const;
 346     uint64_t            sliceOffsetInFile() const;
 347     bool                hasCodeSignature(uint32_t& fileOffset, uint32_t& size) const;
 348     bool                isFairPlayEncrypted(uint32_t& textOffset, uint32_t& size) const;
 349     void                forEachDiskSegment(void (^handler)(uint32_t segIndex, uint32_t fileOffset, uint32_t fileSize, int64_t vmOffset, uint64_t vmSize,
 350                                                           uint8_t permissions, bool laterReadOnly, bool& stop)) const;
 351     void                forEachFixup(void (^rebase)(uint64_t imageOffsetToRebase, bool& stop),
 352                                      void (^bind)(uint64_t imageOffsetToBind, ResolvedSymbolTarget bindTarget, bool& stop),
 353                                      void (^chainedFixups)(uint64_t imageOffsetToStarts, const Array<ResolvedSymbolTarget>& targets, bool& stop),
 354                                      void (^fixupObjCImageInfo)(uint64_t imageOffsetToFixup),
 355                                      void (^fixupObjCProtocol)(uint64_t imageOffsetToBind, ResolvedSymbolTarget bindTarget, bool& stop),
 356                                      void (^fixupObjCSelRef)(uint64_t imageOffsetToFixup, uint32_t selectorIndex, bool inSharedCache, bool& stop),
 357                                      void (^fixupObjCStableSwift)(uint64_t imageOffsetToFixup, bool& stop),
 358                                      void (^fixupObjCMethodList)(uint64_t imageOffsetToFixup, bool& stop)) const;
 359     void                forEachTextReloc(void (^rebase)(uint32_t imageOffsetToRebase, bool& stop),
 360                                          void (^bind)(uint32_t imageOffsetToBind, ResolvedSymbolTarget bindTarget, bool& stop)) const;
 361
 362         static_assert(sizeof(ResolvedSymbolTarget) == 8, "Overflow in size of SymbolTargetLocation");
 363
 364     static uint32_t     hashFunction(const char*);
 365
 366 private:
 367     friend struct Closure;
 368     friend class ImageWriter;
 369     friend class ClosureBuilder;
 370     friend class ClosureWriter;
 371     friend class LaunchClosureWriter;
 372
 373     uint32_t             pageSize() const;
 374
 375     struct Flags
 376     {
 377         uint64_t        imageNum                     : 16,
 378                         maxLoadCount                 : 12,
 379                         isInvalid                    : 1,       // an error occurred creating the info for this image
 380                         has16KBpages                 : 1,
 381                         is64                         : 1,
 382                         hasObjC                      : 1,
 383                         mayHavePlusLoads             : 1,
 384                         isEncrypted                  : 1,       // image is DSMOS or FairPlay encrypted
 385                         hasWeakDefs                  : 1,
 386                         neverUnload                  : 1,
 387                         cwdSameAsThis                : 1,       // dylibs use file system relative paths, cwd must be main's dir
 388                         isPlatformBinary             : 1,       // part of OS - can be loaded into LV process
 389                         isBundle                     : 1,
 390                         isDylib                      : 1,
 391                         isExecutable                 : 1,
 392                         overridableDylib             : 1,       // only applicable to cached dylibs
 393                         inDyldCache                  : 1,
 394                         hasTerminators               : 1,
 395                         hasReadOnlyData              : 1,
 396                         hasChainedFixups             : 1,
 397                         hasPrecomputedObjC           : 1,
 398                         padding                      : 17;
 399     };
 400
 401     static_assert(sizeof(Flags) == sizeof(uint64_t), "Flags overflow");
 402
 403     const Flags&        getFlags() const;
 404
 405     struct PathAndHash
 406     {
 407         uint32_t    hash;
 408         char        path[];
 409     };
 410
 411     // In disk based images, all segments are multiples of page size
 412     // This struct just tracks the size (disk and vm) of each segment.
 413     // This is compact for most every image which have contiguous segments.
 414     // If the image does not have contiguous segments (rare), an extra
 415     // DiskSegment is inserted with the paddingNotSeg bit set.
 416     struct DiskSegment
 417     {
 418         uint64_t    filePageCount   : 30,
 419                     vmPageCount     : 30,
 420                     permissions     : 3,
 421                     paddingNotSeg   : 1;
 422
 423         // We only have three bits for permissions, and need a way to
 424         // encode segments that are initially r/w then made read-only
 425         // after fixups are done.  Previously, the only valid patterns
 426         // were: ---, r--, rw-, r-x.  We now add -w- to mean r/w -> r/o.
 427         enum { kReadOnlyDataPermissions = VM_PROT_WRITE };
 428     };
 429
 430
 431     // In cache DATA_DIRTY is not page aligned or sized
 432     // This struct allows segments with any alignment and up to 256MB in size
 433     struct DyldCacheSegment
 434     {
 435         uint64_t    cacheOffset : 32,
 436                     size        : 28,
 437                     permissions : 4;
 438     };
 439
 440     struct CodeSignatureLocation
 441     {
 442         uint32_t     fileOffset;
 443         uint32_t     fileSize;
 444     };
 445
 446     struct FileInfo
 447     {
 448         uint64_t     inode;
 449         uint64_t     modTime;
 450     };
 451
 452     struct FairPlayRange
 453     {
 454         uint32_t rangeStart;    // The byte offset of the start of the range.
 455         uint32_t rangeLength;   // How long is the fairplay range in bytes
 456     };
 457
 458     struct MappingInfo
 459     {
 460         uint32_t     totalVmPages;
 461         uint32_t     sliceOffsetIn4K;
 462     };
 463
 464     struct InitializerSectionRange
 465     {
 466         uint32_t     sectionOffset;
 467         uint32_t     sectionSize;
 468     };
 469
 470     struct LinkedImage {
 471
 472         LinkedImage() : imgNum(0), linkKind(0) {
 473         }
 474         LinkedImage(LinkKind k, ImageNum num) : imgNum(num), linkKind((uint32_t)k) {
 475             assert((num & 0xC0000000) == 0);
 476         }
 477
 478         LinkKind    kind()  const      { return (LinkKind)linkKind; }
 479         ImageNum    imageNum() const   { return imgNum; }
 480         void        clearKind()        { linkKind = 0; }
 481
 482         bool operator==(const LinkedImage& rhs) const {
 483             return (linkKind == rhs.linkKind) && (imgNum == rhs.imgNum);
 484         }
 485         bool operator!=(const LinkedImage& rhs) const {
 486             return (linkKind != rhs.linkKind) || (imgNum != rhs.imgNum);
 487         }
 488         private:
 489         uint32_t     imgNum         :  30,
 490                      linkKind       :   2;     // LinkKind
 491     };
 492
 493     const Array<LinkedImage> dependentsArray() const;
 494
 495     struct RebasePattern
 496     {
 497         uint32_t    repeatCount   : 20,
 498                     contigCount   :  8, // how many contiguous pointers neeed rebasing
 499                     skipCount     :  4; // how many pointers to skip between contig groups
 500         // If contigCount == 0, then there are no rebases for this entry,
 501         // instead it advances the rebase location by repeatCount*skipCount.
 502         // If all fields are zero, then the rebase position is reset to the start.
 503         // This is to support old binaries with some non-monotonically-increasing rebases.
 504     };
 505     const Array<RebasePattern> rebaseFixups() const;
 506
 507     struct BindPattern
 508     {
 509         Image::ResolvedSymbolTarget     target;
 510         uint64_t                        startVmOffset : 40, // max 1TB offset
 511                                         skipCount     :  8,
 512                                         repeatCount   : 16;
 513     };
 514     const Array<BindPattern> bindFixups() const;
 515
 516     // An optimzied selector reference bind will either point to the shared cache
 517     // or a binary optimized in our launch closure.  We can use the index in to each
 518     // of their respective selector hash tables as the target or the bind.
 519     union SelectorReferenceFixup
 520     {
 521         uint32_t chainStartVMOffset;
 522         struct {
 523             uint32_t    index         : 24, // max 16m entries in the table
 524                         next          : 7,  // (next * 4) -> offset to next fixup
 525                         inSharedCache : 1;  // 0 -> in the closure.  1 -> in the cache
 526         } chainEntry;
 527     };
 528
 529     struct ProtocolISAFixup
 530     {
 531         uint64_t                        startVmOffset : 40, // max 1TB offset
 532                                         skipCount     :  8,
 533                                         repeatCount   : 16;
 534     };
 535
 536     struct ClassStableSwiftFixup
 537     {
 538         uint64_t                        startVmOffset : 40, // max 1TB offset
 539                                         skipCount     :  8,
 540                                         repeatCount   : 16;
 541     };
 542
 543     struct MethodListFixup
 544     {
 545         uint64_t                        startVmOffset : 40, // max 1TB offset
 546                                         skipCount     :  8,
 547                                         repeatCount   : 16;
 548     };
 549
 550     void objcFixups(ResolvedSymbolTarget& objcProtocolClassTarget,
 551                     uint64_t& objcImageInfoVMOffset,
 552                     Array<ProtocolISAFixup>& protocolISAFixups,
 553                     Array<SelectorReferenceFixup>& selRefFixups,
 554                     Array<ClassStableSwiftFixup>& classStableSwiftFixups,
 555                     Array<MethodListFixup>& methodListFixups) const;
 556
 557     struct TextFixupPattern
 558     {
 559         Image::ResolvedSymbolTarget     target;
 560         uint32_t                        startVmOffset;
 561         uint16_t                        repeatCount;
 562         uint16_t                        skipCount;
 563     };
 564     const Array<TextFixupPattern> textFixups() const;
 565
 566     // for use with chained fixups
 567     uint64_t                                  chainedStartsOffset() const;
 568     const Array<Image::ResolvedSymbolTarget>  chainedTargets() const;
 569
 570 };
 571
 572 /*
 573      Dyld cache patching notes:
 574
 575      The dyld cache needs to be patched to support interposing and dylib "roots".
 576
 577      For cached dylibs overrides:
 578          Closure build time:
 579              1) LoadedImages will contain the new dylib, so all symbol look ups
 580                 will naturally find new impl.  Only dyld cache needs special help.
 581              2) LoadedImages entry will have flag for images that override cache.
 582              3) When setting Closure attributes, if flag is set, builder will
 583                 iterate PatchableExport entries in Image* from cache and create
 584                 a PatchEntry for each.
 585          Runtime:
 586              1) [lib]dyld will iterate PatchEntry in closure and patch cache
 587
 588      For interposing:
 589          Closure build time:
 590              1) After Images built, if __interpose section(s) exist, builder will
 591                 build InterposingTuple entries for closure
 592              2) For being-built closure and launch closure, apply any InterposingTuple
 593                 to modify Image fixups before Image finalized.
 594              3) Builder will find PatchableExport entry that matchs stock Impl
 595                 and add PatchEntry to closure for it.
 596          Runtime:
 597              1) When closure is loaded (launch or dlopen) PatchEntries are
 598                 applied (exactly once) to whole cache.
 599              2) For each DlopenClosure loaded, any InterposeTuples in *launch* closure
 600                 are applied to all new images in new DlopenClosure.
 601
 602      For weak-def coalesing:
 603           Closure build time:
 604              1) weak_bind entries are turned into -3 ordinal lookup which search through images
 605                 in load order for first def (like flat). This fixups up all images not in cache.
 606              2) When processing -3 ordinals, it continues past first found and if any images
 607                 past it are in dyld cache and export that same symbol, a PatchEntry is added to
 608                 closure to fix up all cached uses of that symbol.
 609              3) If a weak_bind has strong bit set (no fixup, just def), all images from the dyld
 610                 cache are checked to see if the export that symbol, if so, a PatchEntry is added
 611                 to the closure.
 612           Runtime:
 613              1) When closure is loaded (launch or dlopen) PatchEntries are
 614                 applied (exactly once) to whole cache.
 615
 616 */
 617
 618
 619 //
 620 // An array (accessible by index) list of Images
 621 //
 622 struct VIS_HIDDEN ImageArray : public TypedBytes
 623 {
 624     size_t              size() const;
 625     size_t              startImageNum() const;
 626     uint32_t            imageCount() const;
 627     void                forEachImage(void (^callback)(const Image* image, bool& stop)) const;
 628     bool                hasPath(const char* path, ImageNum& num) const;
 629     const Image*        imageForNum(ImageNum) const;
 630     void                deallocate() const;
 631
 632     static const Image* findImage(const Array<const ImageArray*> imagesArrays, ImageNum imageNum);
 633
 634 private:
 635     friend class ImageArrayWriter;
 636
 637     uint32_t        firstImageNum;
 638     uint32_t        count       : 31;
 639     uint32_t        hasRoots    : 1; // True if this ImageArray contains roots with imageNum's below firstImageNum
 640     uint32_t        offsets[];
 641     // Image data
 642 };
 643
 644
 645 struct InterposingTuple
 646 {
 647     Image::ResolvedSymbolTarget    stockImplementation;
 648     Image::ResolvedSymbolTarget    newImplementation;
 649 };
 650
 651
 652 //
 653 // Describes how dyld should load a set of mach-o files
 654 //
 655 struct VIS_HIDDEN Closure : public ContainerTypedBytes
 656 {
 657     size_t              size() const;
 658     const ImageArray*   images() const;
 659     ImageNum            topImage() const;
 660     void                deallocate() const;
 661
 662     friend class ClosureWriter;
 663
 664     struct PatchEntry
 665     {
 666         ImageNum                    overriddenDylibInCache;
 667         uint32_t                    exportCacheOffset;
 668         Image::ResolvedSymbolTarget replacement;
 669     };
 670
 671     struct Warning
 672     {
 673         enum Type : uint32_t {
 674             duplicateObjCClass = 0
 675         };
 676
 677         Type        type;
 678         char        message[];
 679     };
 680
 681     void                forEachPatchEntry(void (^handler)(const PatchEntry& entry)) const;
 682     void                forEachWarning(Warning::Type type, void (^handler)(const char* warning, bool& stop)) const;
 683 };
 684
 685
 686 //
 687 // Describes how dyld should launch a main executable
 688 //
 689 struct VIS_HIDDEN LaunchClosure : public Closure
 690 {
 691     // Represents a file on disk we tried to load but skipped as it wasn't valid for our use
 692     struct SkippedFile
 693     {
 694         const char* path;
 695         uint64_t    inode;
 696         uint64_t    mtime;
 697     };
 698
 699     bool                builtAgainstDyldCache(uuid_t cacheUUID) const;
 700     const char*         bootUUID() const;
 701     void                forEachMustBeMissingFile(void (^handler)(const char* path, bool& stop)) const;
 702     void                forEachSkipIfExistsFile(void (^handler)(const SkippedFile& file, bool& stop)) const;
 703     void                forEachEnvVar(void (^handler)(const char* keyEqualValue, bool& stop)) const;
 704     ImageNum            libSystemImageNum() const;
 705     void                libDyldEntry(Image::ResolvedSymbolTarget& loc) const;
 706     bool                mainEntry(Image::ResolvedSymbolTarget& mainLoc) const;
 707     bool                startEntry(Image::ResolvedSymbolTarget& startLoc) const;
 708     uint32_t            initialLoadCount() const;
 709     void                forEachInterposingTuple(void (^handler)(const InterposingTuple& tuple, bool& stop)) const;
 710     bool                usedAtPaths() const;
 711     bool                usedFallbackPaths() const;
 712     bool                usedInterposing() const;
 713     bool                selectorHashTable(Array<Image::ObjCSelectorImage>& imageNums,
 714                                           const ObjCSelectorOpt*& hashTable) const;
 715     bool                classAndProtocolHashTables(Array<Image::ObjCClassImage>& imageNums,
 716                                                    const ObjCClassOpt*& classHashTable,
 717                                                    const ObjCClassOpt*& protocolHashTable) const;
 718     void                duplicateClassesHashTable(const ObjCClassDuplicatesOpt*& duplicateClassesHashTable) const;
 719     bool                hasInsertedLibraries() const;
 720     bool                hasInterposings() const;
 721
 722     static bool         buildClosureCachePath(const char* mainExecutablePath, char closurePath[], const char* tempDir,
 723                                               bool makeDirsIfMissing);
 724
 725 private:
 726     friend class LaunchClosureWriter;
 727
 728     struct Flags
 729     {
 730         uint32_t        usedAtPaths              :  1,
 731                         usedFallbackPaths        :  1,
 732                         initImageCount           : 16,
 733                         hasInsertedLibraries     :  1,
 734                         usedInterposing          :  1,
 735                         padding                  : 12;
 736     };
 737     const Flags&        getFlags() const;
 738 };
 739
 740
 741
 742 //
 743 // Describes how dyld should dlopen() a mach-o file
 744 //
 745 struct VIS_HIDDEN DlopenClosure : public Closure
 746 {
 747
 748 };
 749
 750 // Precomputed perfect hash table of strings.
 751 // Base class for closure precomputed selector table and class table.
 752 class VIS_HIDDEN ObjCStringTable {
 753 public:
 754     typedef uint32_t StringTarget;
 755
 756 private:
 757     typedef uint8_t StringHashCheckByte;
 758
 759 protected:
 760
 761     uint32_t capacity;
 762     uint32_t occupied;
 763     uint32_t shift;
 764     uint32_t mask;
 765     StringTarget sentinelTarget;
 766     uint32_t roundedTabSize;
 767     uint64_t salt;
 768
 769     uint32_t scramble[256];
 770     uint8_t tab[0];                   /* tab[mask+1] (always power-of-2). Rounded up to roundedTabSize */
 771     // uint8_t checkbytes[capacity];  /* check byte for each string */
 772     // int32_t offsets[capacity];     /* offsets from &capacity to cstrings */
 773
 774     StringHashCheckByte* checkBytesOffset() {
 775         return &tab[roundedTabSize];
 776     }
 777
 778     const StringHashCheckByte* checkBytesOffset() const {
 779         return &tab[roundedTabSize];
 780     }
 781
 782     StringTarget* targetsOffset() {
 783         return (StringTarget*)(checkBytesOffset() + capacity);
 784     }
 785
 786     const StringTarget* targetsOffset() const {
 787         return (StringTarget*)(checkBytesOffset() + capacity);
 788     }
 789
 790     dyld3::Array<StringHashCheckByte> checkBytes() {
 791         return dyld3::Array<StringHashCheckByte>((StringHashCheckByte *)checkBytesOffset(), capacity, capacity);
 792     }
 793     const dyld3::Array<StringHashCheckByte> checkBytes() const {
 794         return dyld3::Array<StringHashCheckByte>((StringHashCheckByte *)checkBytesOffset(), capacity, capacity);
 795     }
 796
 797     dyld3::Array<StringTarget> targets() {
 798         return dyld3::Array<StringTarget>((StringTarget *)targetsOffset(), capacity, capacity);
 799     }
 800     const dyld3::Array<StringTarget> targets() const {
 801         return dyld3::Array<StringTarget>((StringTarget *)targetsOffset(), capacity, capacity);
 802     }
 803
 804     uint32_t hash(const char *key, size_t keylen) const;
 805
 806     uint32_t hash(const char *key) const
 807     {
 808         return hash(key, strlen(key));
 809     }
 810
 811     // The check bytes areused to reject strings that aren't in the table
 812     // without paging in the table's cstring data. This checkbyte calculation
 813     // catches 4785/4815 rejects when launching Safari; a perfect checkbyte
 814     // would catch 4796/4815.
 815     StringHashCheckByte checkbyte(const char *key, size_t keylen) const
 816     {
 817         return ((key[0] & 0x7) << 5) | ((uint8_t)keylen & 0x1f);
 818     }
 819
 820     StringHashCheckByte checkbyte(const char *key) const
 821     {
 822         return checkbyte(key, strlen(key));
 823     }
 824
 825     StringTarget getPotentialTarget(const char *key) const
 826     {
 827         uint32_t index = getIndex(key);
 828         if (index == indexNotFound)
 829             return sentinelTarget;
 830         return targets()[index];
 831
 832     }
 833
 834 public:
 835
 836     enum : uint32_t {
 837         indexNotFound = ~0U
 838     };
 839
 840     uint32_t getIndex(const char *key) const
 841     {
 842         size_t keylen = strlen(key);
 843         uint32_t h = hash(key, keylen);
 844
 845         // Use check byte to reject without paging in the table's cstrings
 846         StringHashCheckByte h_check = checkBytes()[h];
 847         StringHashCheckByte key_check = checkbyte(key, keylen);
 848         if (h_check != key_check)
 849             return indexNotFound;
 850         return h;
 851     }
 852
 853     template<typename PerfectHashT>
 854     static size_t size(const PerfectHashT& phash) {
 855         // Round tab[] to at least 4 in length to ensure the uint32_t's after are aligned
 856         uint32_t roundedTabSize = std::max(phash.mask+1, 4U);
 857         size_t tableSize = 0;
 858         tableSize += sizeof(ObjCStringTable);
 859         tableSize += roundedTabSize;
 860         tableSize += phash.capacity * sizeof(StringHashCheckByte);
 861         tableSize += phash.capacity * sizeof(StringTarget);
 862         return tableSize;
 863     }
 864
 865     // Get a string if it has an entry in the table
 866     const char* getString(const char* selName, const Array<uintptr_t>& baseAddresses) const;
 867
 868     void forEachString(const Array<Image::ObjCSelectorImage>& selectorImages,
 869                        void (^callback)(uint64_t selVMOffset, ImageNum imageNum)) const;
 870
 871     template<typename PerfectHashT, typename ImageOffsetT>
 872     void write(const PerfectHashT& phash, const Array<std::pair<const char*, ImageOffsetT>>& strings);
 873 };
 874
 875 class VIS_HIDDEN ObjCSelectorOpt : public ObjCStringTable {
 876 public:
 877     // Get a string if it has an entry in the table
 878     // Returns true if an entry is found and sets the imageNum and vmOffset.
 879     bool getStringLocation(uint32_t index, const Array<closure::Image::ObjCSelectorImage>& selImages,
 880                            ImageNum& imageNum, uint64_t& vmOffset) const;
 881
 882     void forEachString(const Array<Image::ObjCSelectorImage>& selectorImages,
 883                        void (^callback)(uint64_t selVMOffset, ImageNum imageNum)) const;
 884 };
 885
 886 class VIS_HIDDEN ObjCClassOpt : public ObjCStringTable {
 887 private:
 888     // ...ObjCStringTable fields...
 889     // ClassTarget classOffsets[capacity]; /* offsets from &capacity to class_t and header_info */
 890     // DuplicateCount duplicateCount;
 891     // ClassTarget duplicateOffsets[duplicatedClasses];
 892
 893     typedef uint32_t DuplicateCount;
 894     typedef Image::ObjCClassImageOffset ClassTarget;
 895
 896     ClassTarget *classOffsetsStart() { return (ClassTarget *)&targetsOffset()[capacity]; }
 897     const ClassTarget *classOffsetsStart() const { return (const ClassTarget *)&targetsOffset()[capacity]; }
 898
 899     dyld3::Array<ClassTarget> classOffsets() {
 900         return dyld3::Array<ClassTarget>((ClassTarget *)classOffsetsStart(), capacity, capacity);
 901     }
 902     const dyld3::Array<ClassTarget> classOffsets() const {
 903         return dyld3::Array<ClassTarget>((ClassTarget *)classOffsetsStart(), capacity, capacity);
 904     }
 905
 906     DuplicateCount& duplicateCount() { return *(DuplicateCount *)&classOffsetsStart()[capacity]; }
 907     const DuplicateCount& duplicateCount() const { return *(const DuplicateCount *)&classOffsetsStart()[capacity]; }
 908
 909     ClassTarget *duplicateOffsetsStart() { return (ClassTarget *)(&duplicateCount()+1); }
 910     const ClassTarget *duplicateOffsetsStart() const { return (const ClassTarget *)(&duplicateCount()+1); }
 911
 912     dyld3::Array<ClassTarget> duplicateOffsets(uint32_t preCalculatedDuplicateCount) {
 913         return dyld3::Array<ClassTarget>((ClassTarget *)duplicateOffsetsStart(), preCalculatedDuplicateCount, duplicateCount());
 914     }
 915     const dyld3::Array<ClassTarget> duplicateOffsets(uint32_t preCalculatedDuplicateCount) const {
 916         return dyld3::Array<ClassTarget>((ClassTarget *)duplicateOffsetsStart(), preCalculatedDuplicateCount, duplicateCount());
 917     }
 918
 919 public:
 920
 921     template<typename PerfectHashT>
 922     static size_t size(PerfectHashT& phash, uint32_t duplicateCount)
 923     {
 924         size_t tableSize = 0;
 925         tableSize += ObjCStringTable::size(phash);
 926         tableSize += phash.capacity * sizeof(ClassTarget);
 927         tableSize += sizeof(DuplicateCount);
 928         tableSize += duplicateCount * sizeof(ClassTarget);
 929         return tableSize;
 930     }
 931
 932     void forEachClass(const char* className,
 933                       const Array<std::pair<uintptr_t, uintptr_t>>& nameAndDataBaseAddresses,
 934                       void (^callback)(void* classPtr, bool isLoaded, bool* stop)) const;
 935
 936     void forEachClass(const Array<Image::ObjCClassImage>& classImages,
 937                       void (^nameCallback)(uint64_t classNameVMOffset, ImageNum imageNum),
 938                       void (^implCallback)(uint64_t classVMOffset, ImageNum imageNum)) const;
 939
 940     template<typename PerfectHashT, typename ImageOffsetT, typename ClassesMapT>
 941     void write(const PerfectHashT& phash, const Array<std::pair<const char*, ImageOffsetT>>& strings,
 942                const ClassesMapT& classes, uint32_t preCalculatedDuplicateCount);
 943 };
 944
 945 class VIS_HIDDEN ObjCClassDuplicatesOpt : public ObjCStringTable {
 946 public:
 947     // Get a class if it has an entry in the table
 948     bool getClassLocation(const char* className, const objc_opt::objc_opt_t* objCOpt, void*& classImpl) const;
 949
 950     void forEachClass(void (^callback)(Image::ObjCDuplicateClass duplicateClass)) const;
 951 };
 952
 953 } //  namespace closure
 954 } //  namespace dyld3
 955
 956
 957 #endif // Closures_h
 958
 959