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
  68
  69                 virtual void            doAtom(const ld::Atom&);
  70                 virtual void            doFile(const class File&);
  71
  72                 void                            resolve();
  73
  74
  75 private:
  76         struct WhyLiveBackChain
  77         {
  78                 WhyLiveBackChain*       previous;
  79                 const ld::Atom*         referer;
  80         };
  81
  82         void                                    initializeState();
  83         void                                    buildAtomList();
  84         void                                    addInitialUndefines();
  85         void                                    deadStripOptimize(bool force=false);
  86         void                                    resolveUndefines();
  87         void                                    checkUndefines(bool force=false);
  88         void                                    checkDylibSymbolCollisions();
  89         void                                    tentativeOverrideOfDylib(ld::Atom&);
  90         void                                    fillInInternalState();
  91         void                                    fillInHelpersInInternalState();
  92         void                                    removeCoalescedAwayAtoms();
  93         void                                    fillInEntryPoint();
  94         void                                    linkTimeOptimize();
  95         void                                    convertReferencesToIndirect(const ld::Atom& atom);
  96         const ld::Atom*                 entryPoint(bool searchArchives);
  97         void                                    markLive(const ld::Atom& atom, WhyLiveBackChain* previous);
  98         bool                                    isDtraceProbe(ld::Fixup::Kind kind);
  99         void                                    liveUndefines(std::vector<const char*>&);
 100         void                                    remainingUndefines(std::vector<const char*>&);
 101         bool                                    printReferencedBy(const char* name, SymbolTable::IndirectBindingSlot slot);
 102         void                                    tweakWeakness();
 103         void                                    doLinkerOption(const std::vector<const char*>& linkerOption, const char* fileName);
 104         void                                    dumpAtoms();
 105
 106         typedef std::unordered_set<const char*, CStringHash, CStringEquals>  StringSet;
 107
 108         class NotLive {
 109         public:
 110                 bool operator()(const ld::Atom* atom) const {
 111                         return ! (atom->live() || atom->dontDeadStrip());
 112                 }
 113         };
 114
 115         class AtomCoalescedAway {
 116         public:
 117                 bool operator()(const ld::Atom* atom) const {
 118                         return atom->coalescedAway();
 119                 }
 120         };
 121
 122         const Options&                                  _options;
 123         InputFiles&                                             _inputFiles;
 124         ld::Internal&                                   _internal;
 125         std::vector<const ld::Atom*>    _atoms;
 126         std::set<const ld::Atom*>               _deadStripRoots;
 127         std::vector<const ld::Atom*>    _atomsWithUnresolvedReferences;
 128         std::vector<const class AliasAtom*>     _aliasesFromCmdLine;
 129         SymbolTable                                             _symbolTable;
 130         bool                                                    _haveLLVMObjs;
 131         bool                                                    _completedInitialObjectFiles;
 132         bool                                                    _ltoCodeGenFinished;
 133 };
 134
 135
 136 class DeadStripResolver
 137 {
 138 public:
 139
 140
 141 private:
 142
 143 };
 144
 145 } // namespace tool
 146 } // namespace ld
 147
 148
 149
 150 #endif // __RESOLVER_H__