ld64/src/ld/parsers/macho_dylib_file.cpp

   1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
   2  *
   3  * Copyright (c) 2005-2011 Apple Inc. All rights reserved.
   4  *
   5  * @APPLE_LICENSE_HEADER_START@
   6  *
   7  * This file contains Original Code and/or Modifications of Original Code
   8  * as defined in and that are subject to the Apple Public Source License
   9  * Version 2.0 (the 'License'). You may not use this file except in
  10  * compliance with the License. Please obtain a copy of the License at
  11  * http://www.opensource.apple.com/apsl/ and read it before using this
  12  * file.
  13  *
  14  * The Original Code and all software distributed under the License are
  15  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  16  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  19  * Please see the License for the specific language governing rights and
  20  * limitations under the License.
  21  *
  22  * @APPLE_LICENSE_HEADER_END@
  23  */
  24
  25
  26 #include <stdint.h>
  27 #include <math.h>
  28 #include <unistd.h>
  29 #include <sys/param.h>
  30 #include <sys/mman.h>
  31
  32
  33 #include <vector>
  34 #include <set>
  35 #include <algorithm>
  36 #include <ext/hash_map>
  37 #include <ext/hash_set>
  38
  39 #include "Architectures.hpp"
  40 #include "MachOFileAbstraction.hpp"
  41 #include "MachOTrie.hpp"
  42 #include "macho_dylib_file.h"
  43 #include "../code-sign-blobs/superblob.h"
  44
  45 namespace mach_o {
  46 namespace dylib {
  47
  48
  49 // forward reference
  50 template <typename A> class File;
  51
  52
  53 //
  54 // An ExportAtom has no content.  It exists so that the linker can track which imported
  55 // symbols came from which dynamic libraries.
  56 //
  57 template <typename A>
  58 class ExportAtom : public ld::Atom
  59 {
  60 public:
  61                                                                                         ExportAtom(const File<A>& f, const char* nm, bool weakDef,
  62                                                                                                                 bool tlv, typename A::P::uint_t address)
  63                                                                                                 : ld::Atom(f._importProxySection, ld::Atom::definitionProxy,
  64                                                                                                         (weakDef? ld::Atom::combineByName : ld::Atom::combineNever),
  65                                                                                                         ld::Atom::scopeLinkageUnit,
  66                                                                                                         (tlv ? ld::Atom::typeTLV : ld::Atom::typeUnclassified),
  67                                                                                                         symbolTableNotIn, false, false, false, ld::Atom::Alignment(0)),
  68                                                                                                         _file(f), _name(nm), _address(address) {}
  69         // overrides of ld::Atom
  70         virtual const ld::File*                                         file() const            { return &_file; }
  71         virtual bool                                                            translationUnitSource(const char** dir, const char** nm) const
  72                                                                                                                                         { return false; }
  73         virtual const char*                                                     name() const            { return _name; }
  74         virtual uint64_t                                                        size() const            { return 0; }
  75         virtual uint64_t                                                        objectAddress() const { return _address; }
  76         virtual void                                                            copyRawContent(uint8_t buffer[]) const { }
  77         virtual void                                                            setScope(Scope)         { }
  78
  79 protected:
  80         typedef typename A::P                                   P;
  81         typedef typename A::P::uint_t                   pint_t;
  82
  83         virtual                                                                 ~ExportAtom() {}
  84
  85         const File<A>&                                                  _file;
  86         const char*                                                             _name;
  87         pint_t                                                                  _address;
  88 };
  89
  90
  91
  92 //
  93 // An ImportAtom has no content.  It exists so that when linking a main executable flat-namespace
  94 // the imports of all flat dylibs are checked
  95 //
  96 template <typename A>
  97 class ImportAtom : public ld::Atom
  98 {
  99 public:
 100                                                                                                 ImportAtom(File<A>& f, std::vector<const char*>& imports);
 101
 102         // overrides of ld::Atom
 103         virtual ld::File*                                                       file() const            { return &_file; }
 104         virtual bool                                                            translationUnitSource(const char** dir, const char** nm) const
 105                                                                                                                                         { return false; }
 106         virtual const char*                                                     name() const            { return "import-atom"; }
 107         virtual uint64_t                                                        size() const            { return 0; }
 108         virtual uint64_t                                                        objectAddress() const { return 0; }
 109         virtual void                                                            copyRawContent(uint8_t buffer[]) const { }
 110         virtual void                                                            setScope(Scope)         { }
 111         virtual ld::Fixup::iterator                                     fixupsBegin() const     { return &_undefs[0]; }
 112         virtual ld::Fixup::iterator                                     fixupsEnd()     const   { return &_undefs[_undefs.size()]; }
 113
 114 protected:
 115         typedef typename A::P                                   P;
 116
 117         virtual                                                                 ~ImportAtom() {}
 118
 119
 120         File<A>&                                                                _file;
 121         mutable std::vector<ld::Fixup>                  _undefs;
 122 };
 123
 124 template <typename A>
 125 ImportAtom<A>::ImportAtom(File<A>& f, std::vector<const char*>& imports)
 126 : ld::Atom(f._flatDummySection, ld::Atom::definitionRegular, ld::Atom::combineNever, ld::Atom::scopeTranslationUnit,
 127         ld::Atom::typeUnclassified, symbolTableNotIn, false, false, false, ld::Atom::Alignment(0)), _file(f)
 128 {
 129         for(std::vector<const char*>::iterator it=imports.begin(); it != imports.end(); ++it) {
 130                 _undefs.push_back(ld::Fixup(0, ld::Fixup::k1of1, ld::Fixup::kindNone, false, strdup(*it)));
 131         }
 132 }
 133
 134
 135
 136 //
 137 // The reader for a dylib extracts all exported symbols names from the memory-mapped
 138 // dylib, builds a hash table, then unmaps the file.  This is an important memory
 139 // savings for large dylibs.
 140 //
 141 template <typename A>
 142 class File : public ld::dylib::File
 143 {
 144 public:
 145         static bool                                                             validFile(const uint8_t* fileContent, bool executableOrDylib);
 146                                                                                         File(const uint8_t* fileContent, uint64_t fileLength, const char* path,
 147                                                                                                         time_t mTime, ld::File::Ordinal ordinal, bool linkingFlatNamespace,
 148                                                                                                         bool linkingMainExecutable, bool hoistImplicitPublicDylibs,
 149                                                                                                         ld::MacVersionMin macMin, ld::IOSVersionMin iPhoneMin, bool addVers,
 150                                                                                                         bool logAllFiles, const char* installPath, bool indirectDylib);
 151         virtual                                                                 ~File() {}
 152
 153         // overrides of ld::File
 154         virtual bool                                                    forEachAtom(ld::File::AtomHandler&) const;
 155         virtual bool                                                    justInTimeforEachAtom(const char* name, ld::File::AtomHandler&) const;
 156         virtual ld::File::ObjcConstraint                objCConstraint() const          { return _objcContraint; }
 157
 158         // overrides of ld::dylib::File
 159         virtual void                                                    processIndirectLibraries(ld::dylib::File::DylibHandler*, bool);
 160         virtual bool                                                    providedExportAtom() const      { return _providedAtom; }
 161         virtual const char*                                             parentUmbrella() const          { return _parentUmbrella; }
 162         virtual const std::vector<const char*>* allowableClients() const        { return _allowableClients.size() != 0 ? &_allowableClients : NULL; }
 163         virtual bool                                                    hasWeakExternals() const        { return _hasWeakExports; }
 164         virtual bool                                                    deadStrippable() const          { return _deadStrippable; }
 165         virtual bool                                                    hasPublicInstallName() const{ return _hasPublicInstallName; }
 166         virtual bool                                                    hasWeakDefinition(const char* name) const;
 167         virtual bool                                                    allSymbolsAreWeakImported() const;
 168         virtual const void*                                             codeSignatureDR() const         { return _codeSignatureDR; }
 169
 170
 171 protected:
 172
 173         struct ReExportChain { ReExportChain* prev; File<A>* file; };
 174
 175         void                                                                                    assertNoReExportCycles(ReExportChain*);
 176
 177 private:
 178         typedef typename A::P                                   P;
 179         typedef typename A::P::E                                E;
 180         typedef typename A::P::uint_t                   pint_t;
 181
 182         friend class ExportAtom<A>;
 183         friend class ImportAtom<A>;
 184
 185         class CStringEquals
 186         {
 187         public:
 188                 bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
 189         };
 190         struct AtomAndWeak { ld::Atom* atom; bool weakDef; bool tlv; pint_t address; };
 191         typedef __gnu_cxx::hash_map<const char*, AtomAndWeak, __gnu_cxx::hash<const char*>, CStringEquals> NameToAtomMap;
 192         typedef __gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals>  NameSet;
 193
 194         struct Dependent { const char* path; File<A>* dylib; bool reExport; };
 195
 196         bool                                                                            containsOrReExports(const char* name, bool* weakDef, bool* tlv, pint_t* defAddress) const;
 197         bool                                                                            isPublicLocation(const char* pth);
 198         void                                                                            addSymbol(const char* name, bool weak, bool tlv, pint_t address);
 199         void                                                                            addDyldFastStub();
 200         void                                                                            buildExportHashTableFromExportInfo(const macho_dyld_info_command<P>* dyldInfo,
 201                                                                                                                                                                 const uint8_t* fileContent);
 202         void                                                                            buildExportHashTableFromSymbolTable(const macho_dysymtab_command<P>* dynamicInfo,
 203                                                                                                                 const macho_nlist<P>* symbolTable, const char* strings,
 204                                                                                                                 const uint8_t* fileContent);
 205         static const char*                                                      objCInfoSegmentName();
 206         static const char*                                                      objCInfoSectionName();
 207
 208         const ld::MacVersionMin                                         _macVersionMin;
 209         const ld::IOSVersionMin                                         _iOSVersionMin;
 210         const bool                                                                      _addVersionLoadCommand;
 211         bool                                                                            _linkingFlat;
 212         bool                                                                            _implicitlyLinkPublicDylibs;
 213         ld::File::ObjcConstraint                                        _objcContraint;
 214         ld::Section                                                                     _importProxySection;
 215         ld::Section                                                                     _flatDummySection;
 216         std::vector<Dependent>                                          _dependentDylibs;
 217         std::vector<const char*>                                        _allowableClients;
 218         mutable NameToAtomMap                                           _atoms;
 219         NameSet                                                                         _ignoreExports;
 220         const char*                                                                     _parentUmbrella;
 221         ImportAtom<A>*                                                          _importAtom;
 222         const void*                                                                     _codeSignatureDR;
 223         bool                                                                            _noRexports;
 224         bool                                                                            _hasWeakExports;
 225         bool                                                                            _deadStrippable;
 226         bool                                                                            _hasPublicInstallName;
 227         mutable bool                                                            _providedAtom;
 228         bool                                                                            _explictReExportFound;
 229
 230         static bool                                                                     _s_logHashtable;
 231 };
 232
 233 template <typename A>
 234 bool File<A>::_s_logHashtable = false;
 235
 236 template <> const char* File<x86_64>::objCInfoSegmentName() { return "__DATA"; }
 237 template <> const char* File<arm>::objCInfoSegmentName() { return "__DATA"; }
 238 template <typename A> const char* File<A>::objCInfoSegmentName() { return "__OBJC"; }
 239
 240 template <> const char* File<x86_64>::objCInfoSectionName() { return "__objc_imageinfo"; }
 241 template <> const char* File<arm>::objCInfoSectionName() { return "__objc_imageinfo"; }
 242 template <typename A> const char* File<A>::objCInfoSectionName() { return "__image_info"; }
 243
 244 template <typename A>
 245 File<A>::File(const uint8_t* fileContent, uint64_t fileLength, const char* pth, time_t mTime, ld::File::Ordinal ord,
 246                                 bool linkingFlatNamespace, bool linkingMainExecutable, bool hoistImplicitPublicDylibs,
 247                                 ld::MacVersionMin macMin, ld::IOSVersionMin iOSMin, bool addVers,
 248                                 bool logAllFiles, const char* targetInstallPath, bool indirectDylib)
 249         : ld::dylib::File(strdup(pth), mTime, ord),
 250         _macVersionMin(macMin), _iOSVersionMin(iOSMin), _addVersionLoadCommand(addVers),
 251         _linkingFlat(linkingFlatNamespace), _implicitlyLinkPublicDylibs(hoistImplicitPublicDylibs),
 252         _objcContraint(ld::File::objcConstraintNone),
 253         _importProxySection("__TEXT", "__import", ld::Section::typeImportProxies, true),
 254         _flatDummySection("__LINKEDIT", "__flat_dummy", ld::Section::typeLinkEdit, true),
 255         _parentUmbrella(NULL), _importAtom(NULL), _codeSignatureDR(NULL),
 256         _noRexports(false), _hasWeakExports(false),
 257         _deadStrippable(false), _hasPublicInstallName(false),
 258          _providedAtom(false), _explictReExportFound(false)
 259 {
 260         const macho_header<P>* header = (const macho_header<P>*)fileContent;
 261         const uint32_t cmd_count = header->ncmds();
 262         const macho_load_command<P>* const cmds = (macho_load_command<P>*)((char*)header + sizeof(macho_header<P>));
 263         const macho_load_command<P>* const cmdsEnd = (macho_load_command<P>*)((char*)header + sizeof(macho_header<P>) + header->sizeofcmds());
 264
 265         // write out path for -t option
 266         if ( logAllFiles )
 267                 printf("%s\n", pth);
 268
 269         // a "blank" stub has zero load commands
 270         if ( (header->filetype() == MH_DYLIB_STUB) && (cmd_count == 0) ) {
 271                 // no further processing needed
 272                 munmap((caddr_t)fileContent, fileLength);
 273                 return;
 274         }
 275
 276
 277         // optimize the case where we know there is no reason to look at indirect dylibs
 278         _noRexports = (header->flags() & MH_NO_REEXPORTED_DYLIBS)
 279                                         || (header->filetype() == MH_BUNDLE)
 280                                         || (header->filetype() == MH_EXECUTE);  // bundles and exectuables can be used via -bundle_loader
 281         _hasWeakExports = (header->flags() & MH_WEAK_DEFINES);
 282         _deadStrippable = (header->flags() & MH_DEAD_STRIPPABLE_DYLIB);
 283
 284         // pass 1: get pointers, and see if this dylib uses compressed LINKEDIT format
 285         const macho_dysymtab_command<P>* dynamicInfo = NULL;
 286         const macho_dyld_info_command<P>* dyldInfo = NULL;
 287         const macho_linkedit_data_command<P>* codeSignature = NULL;
 288         const macho_nlist<P>* symbolTable = NULL;
 289         const char*     strings = NULL;
 290         bool compressedLinkEdit = false;
 291         uint32_t dependentLibCount = 0;
 292         const macho_load_command<P>* cmd = cmds;
 293         for (uint32_t i = 0; i < cmd_count; ++i) {
 294                 macho_dylib_command<P>* dylibID;
 295                 const macho_symtab_command<P>* symtab;
 296                 switch (cmd->cmd()) {
 297                         case LC_SYMTAB:
 298                                 symtab = (macho_symtab_command<P>*)cmd;
 299                                 symbolTable = (const macho_nlist<P>*)((char*)header + symtab->symoff());
 300                                 strings = (char*)header + symtab->stroff();
 301                                 if ( (symtab->stroff() + symtab->strsize()) > fileLength )
 302                                         throwf("mach-o string pool extends beyond end of file in %s", pth);
 303                                 break;
 304                         case LC_DYSYMTAB:
 305                                 dynamicInfo = (macho_dysymtab_command<P>*)cmd;
 306                                 break;
 307                         case LC_DYLD_INFO:
 308                         case LC_DYLD_INFO_ONLY:
 309                                 dyldInfo = (macho_dyld_info_command<P>*)cmd;
 310                                 compressedLinkEdit = true;
 311                                 break;
 312                         case LC_ID_DYLIB:
 313                                 dylibID = (macho_dylib_command<P>*)cmd;
 314                                 _dylibInstallPath                       = strdup(dylibID->name());
 315                                 _dylibTimeStamp                         = dylibID->timestamp();
 316                                 _dylibCurrentVersion            = dylibID->current_version();
 317                                 _dylibCompatibilityVersion      = dylibID->compatibility_version();
 318                                 _hasPublicInstallName           = isPublicLocation(_dylibInstallPath);
 319                                 break;
 320                         case LC_LOAD_DYLIB:
 321                         case LC_LOAD_WEAK_DYLIB:
 322                                 ++dependentLibCount;
 323                                 break;
 324                         case LC_REEXPORT_DYLIB:
 325                                 _explictReExportFound = true;
 326                                 ++dependentLibCount;
 327                                 break;
 328                         case LC_SUB_FRAMEWORK:
 329                                 _parentUmbrella = strdup(((macho_sub_framework_command<P>*)cmd)->umbrella());
 330                                 break;
 331                         case LC_SUB_CLIENT:
 332                                 _allowableClients.push_back(strdup(((macho_sub_client_command<P>*)cmd)->client()));
 333                                 break;
 334                         case LC_VERSION_MIN_MACOSX:
 335                                 if ( _addVersionLoadCommand && !indirectDylib && (_iOSVersionMin != ld::iOSVersionUnset) )
 336                                         warning("building for iOS, but linking against dylib built for MacOSX: %s", pth);
 337                                 break;
 338                         case LC_VERSION_MIN_IPHONEOS:
 339                                 if ( _addVersionLoadCommand && !indirectDylib && (_macVersionMin != ld::macVersionUnset) )
 340                                         warning("building for MacOSX, but linking against dylib built for iOS: %s", pth);
 341                                 break;
 342                         case LC_CODE_SIGNATURE:
 343                                 codeSignature = (macho_linkedit_data_command<P>* )cmd;
 344                                 break;
 345                         case macho_segment_command<P>::CMD:
 346                                 // check for Objective-C info
 347                                 if ( strcmp(((macho_segment_command<P>*)cmd)->segname(), objCInfoSegmentName()) == 0 ) {
 348                                         const macho_segment_command<P>* segment = (macho_segment_command<P>*)cmd;
 349                                         const macho_section<P>* const sectionsStart = (macho_section<P>*)((char*)segment + sizeof(macho_segment_command<P>));
 350                                         const macho_section<P>* const sectionsEnd = &sectionsStart[segment->nsects()];
 351                                         for (const macho_section<P>* sect=sectionsStart; sect < sectionsEnd; ++sect) {
 352                                                 if ( strncmp(sect->sectname(), objCInfoSectionName(), strlen(objCInfoSectionName())) == 0 ) {
 353                                                         //      struct objc_image_info  {
 354                                                         //              uint32_t        version;        // initially 0
 355                                                         //              uint32_t        flags;
 356                                                         //      };
 357                                                         // #define OBJC_IMAGE_SUPPORTS_GC   2
 358                                                         // #define OBJC_IMAGE_GC_ONLY       4
 359                                                         //
 360                                                         const uint32_t* contents = (uint32_t*)(&fileContent[sect->offset()]);
 361                                                         if ( (sect->size() >= 8) && (contents[0] == 0) ) {
 362                                                                 uint32_t flags = E::get32(contents[1]);
 363                                                                 if ( (flags & 4) == 4 )
 364                                                                         _objcContraint = ld::File::objcConstraintGC;
 365                                                                 else if ( (flags & 2) == 2 )
 366                                                                         _objcContraint = ld::File::objcConstraintRetainReleaseOrGC;
 367                                                                 else
 368                                                                         _objcContraint = ld::File::objcConstraintRetainRelease;
 369                                                         }
 370                                                         else if ( sect->size() > 0 ) {
 371                                                                 warning("can't parse %s/%s section in %s", objCInfoSegmentName(), objCInfoSectionName(), this->path());
 372                                                         }
 373                                                 }
 374                                         }
 375                                 }
 376                 }
 377                 cmd = (const macho_load_command<P>*)(((char*)cmd)+cmd->cmdsize());
 378                 if ( cmd > cmdsEnd )
 379                         throwf("malformed dylb, load command #%d is outside size of load commands in %s", i, pth);
 380         }
 381
 382         // figure out if we need to examine dependent dylibs
 383         // with compressed LINKEDIT format, MH_NO_REEXPORTED_DYLIBS can be trusted
 384         bool processDependentLibraries = true;
 385         if  ( compressedLinkEdit && _noRexports && !linkingFlatNamespace)
 386                 processDependentLibraries = false;
 387
 388         if ( processDependentLibraries ) {
 389                 // pass 2 builds list of all dependent libraries
 390                 _dependentDylibs.reserve(dependentLibCount);
 391                 cmd = cmds;
 392                 for (uint32_t i = 0; i < cmd_count; ++i) {
 393                         switch (cmd->cmd()) {
 394                                 case LC_LOAD_DYLIB:
 395                                 case LC_LOAD_WEAK_DYLIB:
 396                                         // with new linkedit format only care about LC_REEXPORT_DYLIB
 397                                         if ( compressedLinkEdit && !linkingFlatNamespace )
 398                                                 break;
 399                                 case LC_REEXPORT_DYLIB:
 400                                         Dependent entry;
 401                                         entry.path = strdup(((macho_dylib_command<P>*)cmd)->name());
 402                                         entry.dylib = NULL;
 403                                         entry.reExport = (cmd->cmd() == LC_REEXPORT_DYLIB);
 404                                         if ( (targetInstallPath == NULL) || (strcmp(targetInstallPath, entry.path) != 0) )
 405                                                 _dependentDylibs.push_back(entry);
 406                                         break;
 407                         }
 408                         cmd = (const macho_load_command<P>*)(((char*)cmd)+cmd->cmdsize());
 409                 }
 410                 // verify MH_NO_REEXPORTED_DYLIBS bit was correct
 411                 if ( compressedLinkEdit && !linkingFlatNamespace ) {
 412                         assert(_dependentDylibs.size() != 0);
 413                 }
 414                 // pass 3 add re-export info
 415                 cmd = cmds;
 416                 for (uint32_t i = 0; i < cmd_count; ++i) {
 417                         const char* frameworkLeafName;
 418                         const char* dylibBaseName;
 419                         switch (cmd->cmd()) {
 420                                 case LC_SUB_UMBRELLA:
 421                                         frameworkLeafName = ((macho_sub_umbrella_command<P>*)cmd)->sub_umbrella();
 422                                         for (typename std::vector<Dependent>::iterator it = _dependentDylibs.begin(); it != _dependentDylibs.end(); ++it) {
 423                                                 const char* dylibName = it->path;
 424                                                 const char* lastSlash = strrchr(dylibName, '/');
 425                                                 if ( (lastSlash != NULL) && (strcmp(&lastSlash[1], frameworkLeafName) == 0) )
 426                                                         it->reExport = true;
 427                                         }
 428                                         break;
 429                                 case LC_SUB_LIBRARY:
 430                                         dylibBaseName = ((macho_sub_library_command<P>*)cmd)->sub_library();
 431                                         for (typename std::vector<Dependent>::iterator it = _dependentDylibs.begin(); it != _dependentDylibs.end(); ++it) {
 432                                                 const char* dylibName = it->path;
 433                                                 const char* lastSlash = strrchr(dylibName, '/');
 434                                                 const char* leafStart = &lastSlash[1];
 435                                                 if ( lastSlash == NULL )
 436                                                         leafStart = dylibName;
 437                                                 const char* firstDot = strchr(leafStart, '.');
 438                                                 int len = strlen(leafStart);
 439                                                 if ( firstDot != NULL )
 440                                                         len = firstDot - leafStart;
 441                                                 if ( strncmp(leafStart, dylibBaseName, len) == 0 )
 442                                                         it->reExport = true;
 443                                         }
 444                                         break;
 445                         }
 446                         cmd = (const macho_load_command<P>*)(((char*)cmd)+cmd->cmdsize());
 447                 }
 448         }
 449
 450         // validate minimal load commands
 451         if ( (_dylibInstallPath == NULL) && ((header->filetype() == MH_DYLIB) || (header->filetype() == MH_DYLIB_STUB)) )
 452                 throwf("dylib %s missing LC_ID_DYLIB load command", pth);
 453         if ( dyldInfo == NULL ) {
 454                 if ( symbolTable == NULL )
 455                         throw "binary missing LC_SYMTAB load command";
 456                 if ( dynamicInfo == NULL )
 457                         throw "binary missing LC_DYSYMTAB load command";
 458         }
 459
 460         // if linking flat and this is a flat dylib, create one atom that references all imported symbols
 461         if ( linkingFlatNamespace && linkingMainExecutable && ((header->flags() & MH_TWOLEVEL) == 0) ) {
 462                 std::vector<const char*> importNames;
 463                 importNames.reserve(dynamicInfo->nundefsym());
 464                 const macho_nlist<P>* start = &symbolTable[dynamicInfo->iundefsym()];
 465                 const macho_nlist<P>* end = &start[dynamicInfo->nundefsym()];
 466                 for (const macho_nlist<P>* sym=start; sym < end; ++sym) {
 467                         importNames.push_back(&strings[sym->n_strx()]);
 468                 }
 469                 _importAtom = new ImportAtom<A>(*this, importNames);
 470         }
 471
 472         // if the dylib is code signed, look for its Designated Requirement
 473         if ( codeSignature != NULL ) {
 474                 const Security::BlobCore* overallSignature = (Security::BlobCore*)((char*)header + codeSignature->dataoff());
 475                 typedef Security::SuperBlob<Security::kSecCodeMagicEmbeddedSignature> EmbeddedSignatureBlob;
 476                 typedef Security::SuperBlob<Security::kSecCodeMagicRequirementSet> InternalRequirementsBlob;
 477                 const EmbeddedSignatureBlob* signature = EmbeddedSignatureBlob::specific(overallSignature);
 478                 if ( signature->validateBlob(codeSignature->datasize()) ) {
 479                         const InternalRequirementsBlob* ireq = signature->find<InternalRequirementsBlob>(Security::cdRequirementsSlot);
 480                         if ( (ireq != NULL) && ireq->validateBlob() ) {
 481                                 const Security::BlobCore* dr = ireq->find(Security::kSecDesignatedRequirementType);
 482                                 if ( (dr != NULL) && dr->validateBlob(Security::kSecCodeMagicRequirement) ) {
 483                                         // <rdar://problem/10968461> make copy because mapped file is about to be unmapped
 484                                         _codeSignatureDR = ::malloc(dr->length());
 485                                         ::memcpy((void*)_codeSignatureDR, dr, dr->length());
 486                                 }
 487                         }
 488                 }
 489         }
 490
 491         // build hash table
 492         if ( dyldInfo != NULL )
 493                 buildExportHashTableFromExportInfo(dyldInfo, fileContent);
 494         else
 495                 buildExportHashTableFromSymbolTable(dynamicInfo, symbolTable, strings, fileContent);
 496
 497         // unmap file
 498         munmap((caddr_t)fileContent, fileLength);
 499 }
 500
 501
 502 template <typename A>
 503 void File<A>::buildExportHashTableFromSymbolTable(const macho_dysymtab_command<P>* dynamicInfo,
 504                                                                                                 const macho_nlist<P>* symbolTable, const char* strings,
 505                                                                                                 const uint8_t* fileContent)
 506 {
 507         if ( dynamicInfo->tocoff() == 0 ) {
 508                 if ( _s_logHashtable ) fprintf(stderr, "ld: building hashtable of %u toc entries for %s\n", dynamicInfo->nextdefsym(), this->path());
 509                 const macho_nlist<P>* start = &symbolTable[dynamicInfo->iextdefsym()];
 510                 const macho_nlist<P>* end = &start[dynamicInfo->nextdefsym()];
 511                 _atoms.resize(dynamicInfo->nextdefsym()); // set initial bucket count
 512                 for (const macho_nlist<P>* sym=start; sym < end; ++sym) {
 513                         this->addSymbol(&strings[sym->n_strx()], (sym->n_desc() & N_WEAK_DEF) != 0, false, sym->n_value());
 514                 }
 515         }
 516         else {
 517                 int32_t count = dynamicInfo->ntoc();
 518                 _atoms.resize(count); // set initial bucket count
 519                 if ( _s_logHashtable ) fprintf(stderr, "ld: building hashtable of %u entries for %s\n", count, this->path());
 520                 const struct dylib_table_of_contents* toc = (dylib_table_of_contents*)(fileContent + dynamicInfo->tocoff());
 521                 for (int32_t i = 0; i < count; ++i) {
 522                         const uint32_t index = E::get32(toc[i].symbol_index);
 523                         const macho_nlist<P>* sym = &symbolTable[index];
 524                         this->addSymbol(&strings[sym->n_strx()], (sym->n_desc() & N_WEAK_DEF) != 0, false, sym->n_value());
 525                 }
 526         }
 527
 528         // special case old libSystem
 529         if ( (_dylibInstallPath != NULL) && (strcmp(_dylibInstallPath, "/usr/lib/libSystem.B.dylib") == 0) )
 530                 addDyldFastStub();
 531 }
 532
 533
 534 template <typename A>
 535 void File<A>::buildExportHashTableFromExportInfo(const macho_dyld_info_command<P>* dyldInfo,
 536                                                                                                                                 const uint8_t* fileContent)
 537 {
 538         if ( _s_logHashtable ) fprintf(stderr, "ld: building hashtable from export info in %s\n", this->path());
 539         if ( dyldInfo->export_size() > 0 ) {
 540                 const uint8_t* start = fileContent + dyldInfo->export_off();
 541                 const uint8_t* end = &start[dyldInfo->export_size()];
 542                 std::vector<mach_o::trie::Entry> list;
 543                 parseTrie(start, end, list);
 544                 for (std::vector<mach_o::trie::Entry>::iterator it=list.begin(); it != list.end(); ++it)
 545                         this->addSymbol(it->name,
 546                                                         it->flags & EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION,
 547                                                         (it->flags & EXPORT_SYMBOL_FLAGS_KIND_MASK) == EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL,
 548                                                          it->address);
 549         }
 550 }
 551
 552
 553 template <>
 554 void File<x86_64>::addDyldFastStub()
 555 {
 556         addSymbol("dyld_stub_binder", false, false, 0);
 557 }
 558
 559 template <>
 560 void File<x86>::addDyldFastStub()
 561 {
 562         addSymbol("dyld_stub_binder", false, false, 0);
 563 }
 564
 565 template <typename A>
 566 void File<A>::addDyldFastStub()
 567 {
 568         // do nothing
 569 }
 570
 571 template <typename A>
 572 void File<A>::addSymbol(const char* name, bool weakDef, bool tlv, pint_t address)
 573 {
 574         if ( weakDef ) {
 575                 assert(_hasWeakExports);
 576         }
 577         //fprintf(stderr, "addSymbol() %s\n", name);
 578         // symbols that start with $ld$ are meta-data to the static linker
 579         // <rdar://problem/5182537> need way for ld and dyld to see different exported symbols in a dylib
 580         if ( strncmp(name, "$ld$", 4) == 0 ) {
 581                 //    $ld$ <action> $ <condition> $ <symbol-name>
 582                 const char* symAction = &name[4];
 583                 const char* symCond = strchr(symAction, '$');
 584                 if ( symCond != NULL ) {
 585                         char curOSVers[16];
 586                         if ( _macVersionMin != ld::macVersionUnset ) {
 587                                 sprintf(curOSVers, "$os%d.%d$", (_macVersionMin >> 16), ((_macVersionMin >> 8) & 0xFF));
 588                         }
 589                         else if ( _iOSVersionMin != ld::iOSVersionUnset ) {
 590                                 sprintf(curOSVers, "$os%d.%d$", (_iOSVersionMin >> 16), ((_iOSVersionMin >> 8) & 0xFF));
 591                         }
 592                         else {
 593                                 assert(0 && "targeting neither macosx nor iphoneos");
 594                         }
 595                         if ( strncmp(symCond, curOSVers, strlen(curOSVers)) == 0 ) {
 596                                 const char* symName = strchr(&symCond[1], '$');
 597                                 if ( symName != NULL ) {
 598                                         ++symName;
 599                                         if ( strncmp(symAction, "hide$", 5) == 0 ) {
 600                                                 if ( _s_logHashtable ) fprintf(stderr, "  adding %s to ignore set for %s\n", symName, this->path());
 601                                                 _ignoreExports.insert(strdup(symName));
 602                                                 return;
 603                                         }
 604                                         else if ( strncmp(symAction, "add$", 4) == 0 ) {
 605                                                 this->addSymbol(symName, weakDef, false, 0);
 606                                                 return;
 607                                         }
 608                                         else if ( strncmp(symAction, "install_name$", 13) == 0 ) {
 609                                                 _dylibInstallPath = symName;
 610                                                 return;
 611                                         }
 612                                         else {
 613                                                 warning("bad symbol action: %s in dylib %s", name, this->path());
 614                                         }
 615                                 }
 616                         }
 617                 }
 618                 else {
 619                         warning("bad symbol condition: %s in dylib %s", name, this->path());
 620                 }
 621         }
 622
 623         // add symbol as possible export if we are not supposed to ignore it
 624         if ( _ignoreExports.count(name) == 0 ) {
 625                 AtomAndWeak bucket;
 626                 bucket.atom = NULL;
 627                 bucket.weakDef = weakDef;
 628                 bucket.tlv = tlv;
 629                 bucket.address = address;
 630                 if ( _s_logHashtable ) fprintf(stderr, "  adding %s to hash table for %s\n", name, this->path());
 631                 _atoms[strdup(name)] = bucket;
 632         }
 633 }
 634
 635
 636 template <typename A>
 637 bool File<A>::forEachAtom(ld::File::AtomHandler& handler) const
 638 {
 639         handler.doFile(*this);
 640         // if doing flatnamespace and need all this dylib's imports resolve
 641         // add atom which references alls undefines in this dylib
 642         if ( _importAtom != NULL ) {
 643                 handler.doAtom(*_importAtom);
 644                 return true;
 645         }
 646         return false;
 647 }
 648
 649 template <typename A>
 650 bool File<A>::hasWeakDefinition(const char* name) const
 651 {
 652         // if supposed to ignore this export, then pretend I don't have it
 653         if ( _ignoreExports.count(name) != 0 )
 654                 return false;
 655
 656         typename NameToAtomMap::const_iterator pos = _atoms.find(name);
 657         if ( pos != _atoms.end() ) {
 658                 return pos->second.weakDef;
 659         }
 660         else {
 661                 // look in children that I re-export
 662                 for (typename std::vector<Dependent>::const_iterator it = _dependentDylibs.begin(); it != _dependentDylibs.end(); ++it) {
 663                         if ( it->reExport ) {
 664                                 //fprintf(stderr, "getJustInTimeAtomsFor: %s NOT found in %s, looking in child %s\n", name, this->path(), (*it)->getInstallPath());
 665                                 typename NameToAtomMap::iterator cpos = it->dylib->_atoms.find(name);
 666                                 if ( cpos != it->dylib->_atoms.end() )
 667                                         return cpos->second.weakDef;
 668                         }
 669                 }
 670         }
 671         return false;
 672 }
 673
 674
 675 // <rdar://problem/5529626> If only weak_import symbols are used, linker should use LD_LOAD_WEAK_DYLIB
 676 template <typename A>
 677 bool File<A>::allSymbolsAreWeakImported() const
 678 {
 679         bool foundNonWeakImport = false;
 680         bool foundWeakImport = false;
 681         //fprintf(stderr, "%s:\n", this->path());
 682         for (typename NameToAtomMap::const_iterator it = _atoms.begin(); it != _atoms.end(); ++it) {
 683                 const ld::Atom* atom = it->second.atom;
 684                 if ( atom != NULL ) {
 685                         if ( atom->weakImported() )
 686                                 foundWeakImport = true;
 687                         else
 688                                 foundNonWeakImport = true;
 689                         //fprintf(stderr, "  weak_import=%d, name=%s\n", atom->weakImported(), it->first);
 690                 }
 691         }
 692
 693         // don't automatically weak link dylib with no imports
 694         // so at least one weak import symbol and no non-weak-imported symbols must be found
 695         return foundWeakImport && !foundNonWeakImport;
 696 }
 697
 698
 699 template <typename A>
 700 bool File<A>::containsOrReExports(const char* name, bool* weakDef, bool* tlv, pint_t* defAddress) const
 701 {
 702         if ( _ignoreExports.count(name) != 0 )
 703                 return false;
 704
 705 // check myself
 706         typename NameToAtomMap::iterator pos = _atoms.find(name);
 707         if ( pos != _atoms.end() ) {
 708                 *weakDef = pos->second.weakDef;
 709                 *tlv = pos->second.tlv;
 710                 *defAddress = pos->second.address;
 711                 return true;
 712         }
 713
 714         // check dylibs I re-export
 715         for (typename std::vector<Dependent>::const_iterator it = _dependentDylibs.begin(); it != _dependentDylibs.end(); ++it) {
 716                 if ( it->reExport && !it->dylib->implicitlyLinked() ) {
 717                         if ( it->dylib->containsOrReExports(name, weakDef, tlv, defAddress) )
 718                                 return true;
 719                 }
 720         }
 721
 722         return false;
 723 }
 724
 725
 726 template <typename A>
 727 bool File<A>::justInTimeforEachAtom(const char* name, ld::File::AtomHandler& handler) const
 728 {
 729         // if supposed to ignore this export, then pretend I don't have it
 730         if ( _ignoreExports.count(name) != 0 )
 731                 return false;
 732
 733
 734         AtomAndWeak bucket;
 735         if ( this->containsOrReExports(name, &bucket.weakDef, &bucket.tlv, &bucket.address) ) {
 736                 bucket.atom = new ExportAtom<A>(*this, name, bucket.weakDef, bucket.tlv, bucket.address);
 737                 _atoms[name] = bucket;
 738                 _providedAtom = true;
 739                 if ( _s_logHashtable ) fprintf(stderr, "getJustInTimeAtomsFor: %s found in %s\n", name, this->path());
 740                 // call handler with new export atom
 741                 handler.doAtom(*bucket.atom);
 742                 return true;
 743         }
 744
 745         return false;
 746 }
 747
 748
 749
 750 template <typename A>
 751 bool File<A>::isPublicLocation(const char* pth)
 752 {
 753         // -no_implicit_dylibs disables this optimization
 754         if ( ! _implicitlyLinkPublicDylibs )
 755                 return false;
 756
 757         // /usr/lib is a public location
 758         if ( (strncmp(pth, "/usr/lib/", 9) == 0) && (strchr(&pth[9], '/') == NULL) )
 759                 return true;
 760
 761         // /System/Library/Frameworks/ is a public location
 762         if ( strncmp(pth, "/System/Library/Frameworks/", 27) == 0 ) {
 763                 const char* frameworkDot = strchr(&pth[27], '.');
 764                 // but only top level framework
 765                 // /System/Library/Frameworks/Foo.framework/Versions/A/Foo                 ==> true
 766                 // /System/Library/Frameworks/Foo.framework/Resources/libBar.dylib         ==> false
 767                 // /System/Library/Frameworks/Foo.framework/Frameworks/Bar.framework/Bar   ==> false
 768                 // /System/Library/Frameworks/Foo.framework/Frameworks/Xfoo.framework/XFoo ==> false
 769                 if ( frameworkDot != NULL ) {
 770                         int frameworkNameLen = frameworkDot - &pth[27];
 771                         if ( strncmp(&pth[strlen(pth)-frameworkNameLen-1], &pth[26], frameworkNameLen+1) == 0 )
 772                                 return true;
 773                 }
 774         }
 775
 776         return false;
 777 }
 778
 779 template <typename A>
 780 void File<A>::processIndirectLibraries(ld::dylib::File::DylibHandler* handler, bool addImplicitDylibs)
 781 {
 782         const static bool log = false;
 783         if ( log ) fprintf(stderr, "processIndirectLibraries(%s)\n", this->installPath());
 784         if ( _linkingFlat ) {
 785                 for (typename std::vector<Dependent>::iterator it = _dependentDylibs.begin(); it != _dependentDylibs.end(); it++) {
 786                         it->dylib = (File<A>*)handler->findDylib(it->path, this->path());
 787                 }
 788         }
 789         else if ( _noRexports ) {
 790                 // MH_NO_REEXPORTED_DYLIBS bit set, then nothing to do
 791         }
 792         else {
 793                 // two-level, might have re-exports
 794                 for (typename std::vector<Dependent>::iterator it = _dependentDylibs.begin(); it != _dependentDylibs.end(); it++) {
 795                         if ( it->reExport ) {
 796                                 if ( log ) fprintf(stderr, "processIndirectLibraries() parent=%s, child=%s\n", this->installPath(), it->path);
 797                                 // a LC_REEXPORT_DYLIB, LC_SUB_UMBRELLA or LC_SUB_LIBRARY says we re-export this child
 798                                 it->dylib = (File<A>*)handler->findDylib(it->path, this->path());
 799                                 if ( it->dylib->hasPublicInstallName() ) {
 800                                         // promote this child to be automatically added as a direct dependent if this already is
 801                                         if ( (this->explicitlyLinked() || this->implicitlyLinked()) && (strcmp(it->path,it->dylib->installPath()) == 0) ) {
 802                                                 if ( log ) fprintf(stderr, "processIndirectLibraries() implicitly linking %s\n", it->dylib->installPath());
 803                                                 it->dylib->setImplicitlyLinked();
 804                                         }
 805                                         else if ( it->dylib->explicitlyLinked() || it->dylib->implicitlyLinked() ) {
 806                                                 if ( log ) fprintf(stderr, "processIndirectLibraries() parent is not directly linked, but child is, so no need to re-export child\n");
 807                                         }
 808                                         else {
 809                                                 if ( log ) fprintf(stderr, "processIndirectLibraries() parent is not directly linked, so parent=%s will re-export child=%s\n", this->installPath(), it->path);
 810                                         }
 811                                 }
 812                                 else {
 813                                         // add all child's symbols to me
 814                                         if ( log ) fprintf(stderr, "processIndirectLibraries() child is not public, so parent=%s will re-export child=%s\n", this->installPath(), it->path);
 815                                 }
 816                         }
 817                         else if ( !_explictReExportFound ) {
 818                                 // see if child contains LC_SUB_FRAMEWORK with my name
 819                                 it->dylib = (File<A>*)handler->findDylib(it->path, this->path());
 820                                 const char* parentUmbrellaName = it->dylib->parentUmbrella();
 821                                 if ( parentUmbrellaName != NULL ) {
 822                                         const char* parentName = this->path();
 823                                         const char* lastSlash = strrchr(parentName, '/');
 824                                         if ( (lastSlash != NULL) && (strcmp(&lastSlash[1], parentUmbrellaName) == 0) ) {
 825                                                 // add all child's symbols to me
 826                                                 it->reExport = true;
 827                                                 if ( log ) fprintf(stderr, "processIndirectLibraries() umbrella=%s will re-export child=%s\n", this->installPath(), it->path);
 828                                         }
 829                                 }
 830                         }
 831                 }
 832         }
 833
 834         // check for re-export cycles
 835         ReExportChain chain;
 836         chain.prev = NULL;
 837         chain.file = this;
 838         this->assertNoReExportCycles(&chain);
 839 }
 840
 841 template <typename A>
 842 void File<A>::assertNoReExportCycles(ReExportChain* prev)
 843 {
 844         // recursively check my re-exported dylibs
 845         ReExportChain chain;
 846         chain.prev = prev;
 847         chain.file = this;
 848         for (typename std::vector<Dependent>::iterator it = _dependentDylibs.begin(); it != _dependentDylibs.end(); it++) {
 849                 if ( it->reExport ) {
 850                         ld::File* child = it->dylib;
 851                         // check child is not already in chain
 852                         for (ReExportChain* p = prev; p != NULL; p = p->prev) {
 853                                 if ( p->file == child ) {
 854                                         throwf("cycle in dylib re-exports with %s and %s", child->path(), this->path());
 855                                 }
 856                         }
 857                         if ( it->dylib != NULL )
 858                                 it->dylib->assertNoReExportCycles(&chain);
 859                 }
 860         }
 861 }
 862
 863
 864 template <typename A>
 865 class Parser
 866 {
 867 public:
 868         typedef typename A::P                                   P;
 869
 870         static bool                                                                             validFile(const uint8_t* fileContent, bool executableOrDyliborBundle);
 871         static ld::dylib::File*                                                 parse(const uint8_t* fileContent, uint64_t fileLength,
 872                                                                                                                         const char* path, time_t mTime,
 873                                                                                                                         ld::File::Ordinal ordinal, const Options& opts, bool indirectDylib) {
 874                                                                                                                         return new File<A>(fileContent, fileLength, path, mTime,
 875                                                                                                                                                         ordinal, opts.flatNamespace(),
 876                                                                                                                                                         opts.linkingMainExecutable(),
 877                                                                                                                                                         opts.implicitlyLinkIndirectPublicDylibs(),
 878                                                                                                                                                         opts.macosxVersionMin(),
 879                                                                                                                                                         opts.iOSVersionMin(),
 880                                                                                                                                                         opts.addVersionLoadCommand(),
 881                                                                                                                                                         opts.logAllFiles(),
 882                                                                                                                                                         opts.installPath(),
 883                                                                                                                                                         indirectDylib);
 884                                                                                                                 }
 885
 886 };
 887
 888
 889
 890 template <>
 891 bool Parser<x86>::validFile(const uint8_t* fileContent, bool executableOrDyliborBundle)
 892 {
 893         const macho_header<P>* header = (const macho_header<P>*)fileContent;
 894         if ( header->magic() != MH_MAGIC )
 895                 return false;
 896         if ( header->cputype() != CPU_TYPE_I386 )
 897                 return false;
 898         switch ( header->filetype() ) {
 899                 case MH_DYLIB:
 900                 case MH_DYLIB_STUB:
 901                         return true;
 902                 case MH_BUNDLE:
 903                         if ( executableOrDyliborBundle )
 904                                 return true;
 905                         else
 906                                 throw "can't link with bundle (MH_BUNDLE) only dylibs (MH_DYLIB)";
 907                 case MH_EXECUTE:
 908                         if ( executableOrDyliborBundle )
 909                                 return true;
 910                         else
 911                                 throw "can't link with a main executable";
 912                 default:
 913                         return false;
 914         }
 915 }
 916
 917 template <>
 918 bool Parser<x86_64>::validFile(const uint8_t* fileContent, bool executableOrDyliborBundle)
 919 {
 920         const macho_header<P>* header = (const macho_header<P>*)fileContent;
 921         if ( header->magic() != MH_MAGIC_64 )
 922                 return false;
 923         if ( header->cputype() != CPU_TYPE_X86_64 )
 924                 return false;
 925         switch ( header->filetype() ) {
 926                 case MH_DYLIB:
 927                 case MH_DYLIB_STUB:
 928                         return true;
 929                 case MH_BUNDLE:
 930                         if ( executableOrDyliborBundle )
 931                                 return true;
 932                         else
 933                                 throw "can't link with bundle (MH_BUNDLE) only dylibs (MH_DYLIB)";
 934                 case MH_EXECUTE:
 935                         if ( executableOrDyliborBundle )
 936                                 return true;
 937                         else
 938                                 throw "can't link with a main executable";
 939                 default:
 940                         return false;
 941         }
 942 }
 943
 944 template <>
 945 bool Parser<arm>::validFile(const uint8_t* fileContent, bool executableOrDyliborBundle)
 946 {
 947         const macho_header<P>* header = (const macho_header<P>*)fileContent;
 948         if ( header->magic() != MH_MAGIC )
 949                 return false;
 950         if ( header->cputype() != CPU_TYPE_ARM )
 951                 return false;
 952         switch ( header->filetype() ) {
 953                 case MH_DYLIB:
 954                 case MH_DYLIB_STUB:
 955                         return true;
 956                 case MH_BUNDLE:
 957                         if ( executableOrDyliborBundle )
 958                                 return true;
 959                         else
 960                                 throw "can't link with bundle (MH_BUNDLE) only dylibs (MH_DYLIB)";
 961                 case MH_EXECUTE:
 962                         if ( executableOrDyliborBundle )
 963                                 return true;
 964                         else
 965                                 throw "can't link with a main executable";
 966                 default:
 967                         return false;
 968         }
 969 }
 970
 971
 972
 973 //
 974 // main function used by linker to instantiate ld::Files
 975 //
 976 ld::dylib::File* parse(const uint8_t* fileContent, uint64_t fileLength,
 977                                                         const char* path, time_t modTime, const Options& opts, ld::File::Ordinal ordinal,
 978                                                         bool bundleLoader, bool indirectDylib)
 979 {
 980         switch ( opts.architecture() ) {
 981 #if SUPPORT_ARCH_x86_64
 982                 case CPU_TYPE_X86_64:
 983                         if ( Parser<x86_64>::validFile(fileContent, bundleLoader) )
 984                                 return Parser<x86_64>::parse(fileContent, fileLength, path, modTime, ordinal, opts, indirectDylib);
 985                         break;
 986 #endif
 987 #if SUPPORT_ARCH_i386
 988                 case CPU_TYPE_I386:
 989                         if ( Parser<x86>::validFile(fileContent, bundleLoader) )
 990                                 return Parser<x86>::parse(fileContent, fileLength, path, modTime, ordinal, opts, indirectDylib);
 991                         break;
 992 #endif
 993 #if SUPPORT_ARCH_arm_any
 994                 case CPU_TYPE_ARM:
 995                         if ( Parser<arm>::validFile(fileContent, bundleLoader) )
 996                                 return Parser<arm>::parse(fileContent, fileLength, path, modTime, ordinal, opts, indirectDylib);
 997                         break;
 998 #endif
 999         }
1000         return NULL;
1001 }
1002
1003
1004 }; // namespace dylib
1005 }; // namespace mach_o
1006
1007