src/ld/Resolver.h

   1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-*
   2  *
   3  * Copyright (c) 2009 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 #ifndef __RESOLVER_H__
  26 #define __RESOLVER_H__
  27
  28 #include <stdlib.h>
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <sys/mman.h>
  32 #include <sys/sysctl.h>
  33 #include <fcntl.h>
  34 #include <errno.h>
  35 #include <limits.h>
  36 #include <unistd.h>
  37 #include <mach/mach_time.h>
  38 #include <mach/vm_statistics.h>
  39 #include <mach/mach_init.h>
  40 #include <mach/mach_host.h>
  41 #include <dlfcn.h>
  42 #include <mach-o/dyld.h>
  43
  44 #include <vector>
  45 #include <unordered_set>
  46
  47 #include "Options.h"
  48 #include "ld.hpp"
  49 #include "SymbolTable.h"
  50
  51
  52 namespace ld {
  53 namespace tool {
  54
  55
  56
  57
  58 class Resolver : public ld::File::AtomHandler
  59 {
  60 public:
  61                                                         Resolver(const Options& opts, InputFiles& inputs, ld::Internal& state)
  62                                                                 : _options(opts), _inputFiles(inputs), _internal(state),
  63                                                                   _symbolTable(opts, state.indirectBindingTable),
  64                                                                   _haveLLVMObjs(false),
  65                                                                   _completedInitialObjectFiles(false),
  66                                                                   _ltoCodeGenFinished(false),
  67                                                                   _haveAliases(false) {}
  68
  69
  70                 virtual void            doAtom(const ld::Atom&);
  71                 virtual void            doFile(const class File&);
  72
  73                 void                            resolve();
  74
  75
  76 private:
  77         struct WhyLiveBackChain
  78         {
  79                 WhyLiveBackChain*       previous;
  80                 const ld::Atom*         referer;
  81         };
  82
  83         void                                    initializeState();
  84         void                                    buildAtomList();
  85         void                                    addInitialUndefines();
  86         void                                    deadStripOptimize(bool force=false);
  87         void                                    resolveUndefines();
  88         void                                    checkUndefines(bool force=false);
  89         void                                    checkDylibSymbolCollisions();
  90         void                                    tentativeOverrideOfDylib(ld::Atom&);
  91         void                                    fillInInternalState();
  92         void                                    fillInHelpersInInternalState();
  93         void                                    removeCoalescedAwayAtoms();
  94         void                                    syncAliases();
  95         void                                    fillInEntryPoint();
  96         void                                    linkTimeOptimize();
  97         void                                    convertReferencesToIndirect(const ld::Atom& atom);
  98         const ld::Atom*                 entryPoint(bool searchArchives);
  99         void                                    markLive(const ld::Atom& atom, WhyLiveBackChain* previous);
 100         bool                                    isDtraceProbe(ld::Fixup::Kind kind);
 101         void                                    liveUndefines(std::vector<const char*>&);
 102         void                                    remainingUndefines(std::vector<const char*>&);
 103         bool                                    printReferencedBy(const char* name, SymbolTable::IndirectBindingSlot slot);
 104         void                                    tweakWeakness();
 105         void                                    buildArchivesList();
 106         void                                    doLinkerOption(const std::vector<const char*>& linkerOption, const char* fileName);
 107         void                                    dumpAtoms();
 108
 109         typedef std::unordered_set<const char*, CStringHash, CStringEquals>  StringSet;
 110
 111         class NotLive {
 112         public:
 113                 bool operator()(const ld::Atom* atom) const {
 114                         return ! (atom->live() || atom->dontDeadStrip());
 115                 }
 116         };
 117
 118         class AtomCoalescedAway {
 119         public:
 120                 bool operator()(const ld::Atom* atom) const {
 121                         return atom->coalescedAway();
 122                 }
 123         };
 124
 125         const Options&                                  _options;
 126         InputFiles&                                             _inputFiles;
 127         ld::Internal&                                   _internal;
 128         std::vector<const ld::Atom*>    _atoms;
 129         std::set<const ld::Atom*>               _deadStripRoots;
 130         std::vector<const ld::Atom*>    _dontDeadStripIfReferencesLive;
 131         std::vector<const ld::Atom*>    _atomsWithUnresolvedReferences;
 132         std::vector<const class AliasAtom*>     _aliasesFromCmdLine;
 133         SymbolTable                                             _symbolTable;
 134         bool                                                    _haveLLVMObjs;
 135         bool                                                    _completedInitialObjectFiles;
 136         bool                                                    _ltoCodeGenFinished;
 137         bool                                                    _haveAliases;
 138 };
 139
 140
 141 class DeadStripResolver
 142 {
 143 public:
 144
 145
 146 private:
 147
 148 };
 149
 150 } // namespace tool
 151 } // namespace ld
 152
 153
 154
 155 #endif // __RESOLVER_H__