Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 1 | //===- Core/Resolver.cpp - Resolves Atom References -----------------------===// |
| 2 | // |
| 3 | // The LLVM Linker |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 10 | #include "lld/Core/Atom.h" |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 11 | #include "lld/Core/ArchiveLibraryFile.h" |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 12 | #include "lld/Core/File.h" |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 13 | #include "lld/Core/SharedLibraryFile.h" |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 14 | #include "lld/Core/Instrumentation.h" |
Michael J. Spencer | e6203a5 | 2012-04-03 18:39:40 +0000 | [diff] [blame] | 15 | #include "lld/Core/LLVM.h" |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 16 | #include "lld/Core/Resolver.h" |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 17 | #include "lld/Core/SymbolTable.h" |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 18 | #include "lld/Core/LinkingContext.h" |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 19 | #include "lld/Core/UndefinedAtom.h" |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 20 | |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 21 | #include "llvm/Support/Debug.h" |
Michael J. Spencer | 4586fbc | 2013-01-22 20:49:42 +0000 | [diff] [blame] | 22 | #include "llvm/Support/ErrorHandling.h" |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 23 | #include "llvm/Support/Format.h" |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 24 | #include "llvm/Support/raw_ostream.h" |
| 25 | |
| 26 | #include <algorithm> |
| 27 | #include <cassert> |
| 28 | #include <vector> |
| 29 | |
| 30 | namespace lld { |
| 31 | |
Nick Kledzik | 80d8308 | 2013-05-08 21:34:11 +0000 | [diff] [blame] | 32 | namespace { |
| 33 | |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 34 | /// This is used as a filter function to std::remove_if to dead strip atoms. |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 35 | class NotLive { |
| 36 | public: |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 37 | explicit NotLive(const llvm::DenseSet<const Atom *> &la) : _liveAtoms(la) {} |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 38 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 39 | bool operator()(const Atom *atom) const { |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 40 | // don't remove if live |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 41 | if (_liveAtoms.count(atom)) |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 42 | return false; |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 43 | // don't remove if marked never-dead-strip |
Rui Ueyama | c53b3b0 | 2013-12-10 06:19:09 +0000 | [diff] [blame] | 44 | if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom)) |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 45 | if (defAtom->deadStrip() == DefinedAtom::deadStripNever) |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 46 | return false; |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 47 | // do remove this atom |
| 48 | return true; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 49 | } |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 50 | |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 51 | private: |
Rui Ueyama | 0cbd7e0 | 2013-12-26 06:57:37 +0000 | [diff] [blame] | 52 | const llvm::DenseSet<const Atom *> &_liveAtoms; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 53 | }; |
| 54 | |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 55 | /// This is used as a filter function to std::remove_if to coalesced atoms. |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 56 | class AtomCoalescedAway { |
| 57 | public: |
Nick Kledzik | 80d8308 | 2013-05-08 21:34:11 +0000 | [diff] [blame] | 58 | explicit AtomCoalescedAway(SymbolTable &sym) : _symbolTable(sym) {} |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 59 | |
| 60 | bool operator()(const Atom *atom) const { |
| 61 | const Atom *rep = _symbolTable.replacement(atom); |
| 62 | return rep != atom; |
| 63 | } |
| 64 | |
| 65 | private: |
| 66 | SymbolTable &_symbolTable; |
| 67 | }; |
| 68 | |
Nick Kledzik | 80d8308 | 2013-05-08 21:34:11 +0000 | [diff] [blame] | 69 | } // namespace |
| 70 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 71 | // called before the first atom in any file is added with doAtom() |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 72 | void Resolver::doFile(const File &file) {} |
| 73 | |
| 74 | void Resolver::handleFile(const File &file) { |
Rui Ueyama | 8b8e521 | 2013-10-08 03:59:45 +0000 | [diff] [blame] | 75 | uint32_t resolverState = Resolver::StateNoChange; |
Shankar Easwaran | 178324d | 2013-11-21 03:50:59 +0000 | [diff] [blame] | 76 | const SharedLibraryFile *sharedLibraryFile = |
| 77 | llvm::dyn_cast<SharedLibraryFile>(&file); |
| 78 | |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 79 | doFile(file); |
| 80 | for (const DefinedAtom *atom : file.defined()) { |
| 81 | doDefinedAtom(*atom); |
| 82 | resolverState |= StateNewDefinedAtoms; |
| 83 | } |
Shankar Easwaran | 178324d | 2013-11-21 03:50:59 +0000 | [diff] [blame] | 84 | if (!sharedLibraryFile || |
| 85 | _context.addUndefinedAtomsFromSharedLibrary(sharedLibraryFile)) { |
| 86 | for (const UndefinedAtom *undefAtom : file.undefined()) { |
| 87 | doUndefinedAtom(*undefAtom); |
| 88 | resolverState |= StateNewUndefinedAtoms; |
| 89 | // If the undefined symbol has an alternative name, try to resolve the |
| 90 | // symbol with the name to give it a second chance. This feature is used |
| 91 | // for COFF "weak external" symbol. |
| 92 | if (!_symbolTable.isDefined(undefAtom->name())) { |
| 93 | if (const UndefinedAtom *fallbackAtom = undefAtom->fallback()) { |
| 94 | doUndefinedAtom(*fallbackAtom); |
| 95 | _symbolTable.addReplacement(undefAtom, fallbackAtom); |
| 96 | } |
Rui Ueyama | 70f11d7 | 2013-11-20 20:51:55 +0000 | [diff] [blame] | 97 | } |
| 98 | } |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 99 | } |
| 100 | for (const SharedLibraryAtom *shlibAtom : file.sharedLibrary()) { |
| 101 | doSharedLibraryAtom(*shlibAtom); |
| 102 | resolverState |= StateNewSharedLibraryAtoms; |
| 103 | } |
| 104 | for (const AbsoluteAtom *absAtom : file.absolute()) { |
| 105 | doAbsoluteAtom(*absAtom); |
| 106 | resolverState |= StateNewAbsoluteAtoms; |
| 107 | } |
Rui Ueyama | eb4b543 | 2014-04-02 05:03:40 +0000 | [diff] [blame^] | 108 | _context.inputGraph().setResolverState(resolverState); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 109 | } |
| 110 | |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 111 | void Resolver::forEachUndefines(UndefCallback callback, |
| 112 | bool searchForOverrides) { |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 113 | // Handle normal archives |
| 114 | int64_t undefineGenCount = 0; |
| 115 | do { |
| 116 | undefineGenCount = _symbolTable.size(); |
| 117 | std::vector<const UndefinedAtom *> undefines; |
| 118 | _symbolTable.undefines(undefines); |
| 119 | for (const UndefinedAtom *undefAtom : undefines) { |
| 120 | StringRef undefName = undefAtom->name(); |
| 121 | // load for previous undefine may also have loaded this undefine |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 122 | if (!_symbolTable.isDefined(undefName)) |
| 123 | callback(undefName, false); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 124 | } |
| 125 | // search libraries for overrides of common symbols |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 126 | if (searchForOverrides) { |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 127 | std::vector<StringRef> tentDefNames; |
| 128 | _symbolTable.tentativeDefinitions(tentDefNames); |
| 129 | for (StringRef tentDefName : tentDefNames) { |
| 130 | // Load for previous tentative may also have loaded |
| 131 | // something that overrode this tentative, so always check. |
| 132 | const Atom *curAtom = _symbolTable.findByName(tentDefName); |
| 133 | assert(curAtom != nullptr); |
| 134 | if (const DefinedAtom *curDefAtom = dyn_cast<DefinedAtom>(curAtom)) { |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 135 | if (curDefAtom->merge() == DefinedAtom::mergeAsTentative) |
| 136 | callback(tentDefName, true); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 137 | } |
| 138 | } |
| 139 | } |
| 140 | } while (undefineGenCount != _symbolTable.size()); |
| 141 | } |
| 142 | |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 143 | void Resolver::handleArchiveFile(const File &file) { |
| 144 | const ArchiveLibraryFile *archiveFile = dyn_cast<ArchiveLibraryFile>(&file); |
| 145 | auto callback = [&](StringRef undefName, bool dataSymbolOnly) { |
| 146 | if (const File *member = archiveFile->find(undefName, dataSymbolOnly)) { |
| 147 | member->setOrdinal(_context.getNextOrdinalAndIncrement()); |
| 148 | handleFile(*member); |
| 149 | } |
| 150 | }; |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 151 | bool searchForOverrides = |
| 152 | _context.searchArchivesToOverrideTentativeDefinitions(); |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 153 | forEachUndefines(callback, searchForOverrides); |
| 154 | } |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 155 | |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 156 | void Resolver::handleSharedLibrary(const File &file) { |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 157 | // Add all the atoms from the shared library |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 158 | const SharedLibraryFile *sharedLibrary = dyn_cast<SharedLibraryFile>(&file); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 159 | handleFile(*sharedLibrary); |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 160 | |
| 161 | auto callback = [&](StringRef undefName, bool dataSymbolOnly) { |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 162 | if (const SharedLibraryAtom *shAtom = |
| 163 | sharedLibrary->exports(undefName, dataSymbolOnly)) |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 164 | doSharedLibraryAtom(*shAtom); |
| 165 | }; |
| 166 | bool searchForOverrides = |
| 167 | _context.searchSharedLibrariesToOverrideTentativeDefinitions(); |
| 168 | forEachUndefines(callback, searchForOverrides); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 169 | } |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 170 | |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 171 | void Resolver::doUndefinedAtom(const UndefinedAtom &atom) { |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 172 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
| 173 | << " UndefinedAtom: " |
| 174 | << llvm::format("0x%09lX", &atom) |
| 175 | << ", name=" |
| 176 | << atom.name() |
| 177 | << "\n"); |
| 178 | |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 179 | // add to list of known atoms |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 180 | _atoms.push_back(&atom); |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 181 | |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 182 | // tell symbol table |
| 183 | _symbolTable.add(atom); |
| 184 | } |
| 185 | |
Shankar Easwaran | 7ac2a3d | 2014-03-26 16:37:13 +0000 | [diff] [blame] | 186 | /// \brief Add the section group and the group-child reference members. |
Shankar Easwaran | 9316c40 | 2014-04-01 03:49:55 +0000 | [diff] [blame] | 187 | bool Resolver::maybeAddSectionGroupOrGnuLinkOnce(const DefinedAtom &atom) { |
Shankar Easwaran | 7ac2a3d | 2014-03-26 16:37:13 +0000 | [diff] [blame] | 188 | // First time adding a group ? |
| 189 | bool isFirstTime = _symbolTable.addGroup(atom); |
Shankar Easwaran | 9316c40 | 2014-04-01 03:49:55 +0000 | [diff] [blame] | 190 | |
| 191 | if (!isFirstTime) { |
| 192 | // If duplicate symbols are allowed, select the first group. |
| 193 | if (_context.getAllowDuplicates()) |
| 194 | return true; |
| 195 | const DefinedAtom *prevGroup = |
| 196 | llvm::dyn_cast<DefinedAtom>(_symbolTable.findGroup(atom.name())); |
| 197 | assert(prevGroup && |
| 198 | "Internal Error: The group atom could only be a defined atom"); |
| 199 | // The atoms should be of the same content type, reject invalid group |
| 200 | // resolution behaviors. |
| 201 | if (atom.contentType() != prevGroup->contentType()) |
| 202 | return false; |
| 203 | return true; |
| 204 | } |
Shankar Easwaran | 7ac2a3d | 2014-03-26 16:37:13 +0000 | [diff] [blame] | 205 | |
| 206 | for (const Reference *r : atom) { |
| 207 | if ((r->kindNamespace() == lld::Reference::KindNamespace::all) && |
| 208 | (r->kindValue() == lld::Reference::kindGroupChild)) { |
| 209 | const DefinedAtom *target = llvm::dyn_cast<DefinedAtom>(r->target()); |
| 210 | assert(target && "Internal Error: kindGroupChild references need to " |
| 211 | "be associated with Defined Atoms only"); |
| 212 | _atoms.push_back(target); |
| 213 | _symbolTable.add(*target); |
| 214 | } |
| 215 | } |
Shankar Easwaran | 9316c40 | 2014-04-01 03:49:55 +0000 | [diff] [blame] | 216 | return true; |
Shankar Easwaran | 7ac2a3d | 2014-03-26 16:37:13 +0000 | [diff] [blame] | 217 | } |
| 218 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 219 | // called on each atom when a file is added |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 220 | void Resolver::doDefinedAtom(const DefinedAtom &atom) { |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 221 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
| 222 | << " DefinedAtom: " |
| 223 | << llvm::format("0x%09lX", &atom) |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 224 | << ", file=#" |
| 225 | << atom.file().ordinal() |
| 226 | << ", atom=#" |
| 227 | << atom.ordinal() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 228 | << ", name=" |
| 229 | << atom.name() |
| 230 | << "\n"); |
| 231 | |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 232 | // Verify on zero-size atoms are pinned to start or end of section. |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 233 | switch (atom.sectionPosition()) { |
Shankar Easwaran | 8962feb | 2013-03-14 16:09:49 +0000 | [diff] [blame] | 234 | case DefinedAtom::sectionPositionStart: |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 235 | case DefinedAtom::sectionPositionEnd: |
Rui Ueyama | e20474d | 2013-11-13 03:30:29 +0000 | [diff] [blame] | 236 | assert(atom.size() == 0); |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 237 | break; |
Shankar Easwaran | 8962feb | 2013-03-14 16:09:49 +0000 | [diff] [blame] | 238 | case DefinedAtom::sectionPositionEarly: |
| 239 | case DefinedAtom::sectionPositionAny: |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 240 | break; |
| 241 | } |
| 242 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 243 | // add to list of known atoms |
| 244 | _atoms.push_back(&atom); |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 245 | |
Shankar Easwaran | 9316c40 | 2014-04-01 03:49:55 +0000 | [diff] [blame] | 246 | if (atom.isGroupParent()) { |
| 247 | // Raise error if there exists a similar gnu linkonce section. |
| 248 | if (!maybeAddSectionGroupOrGnuLinkOnce(atom)) { |
| 249 | llvm::errs() << "SymbolTable: error while merging " << atom.name() |
| 250 | << "\n"; |
| 251 | llvm::report_fatal_error("duplicate symbol error"); |
| 252 | } |
| 253 | } else { |
Shankar Easwaran | 7ac2a3d | 2014-03-26 16:37:13 +0000 | [diff] [blame] | 254 | _symbolTable.add(atom); |
Shankar Easwaran | 9316c40 | 2014-04-01 03:49:55 +0000 | [diff] [blame] | 255 | } |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 256 | |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 257 | if (_context.deadStrip()) { |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 258 | // add to set of dead-strip-roots, all symbols that |
| 259 | // the compiler marks as don't strip |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 260 | if (atom.deadStrip() == DefinedAtom::deadStripNever) |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 261 | _deadStripRoots.insert(&atom); |
| 262 | } |
| 263 | } |
| 264 | |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 265 | void Resolver::doSharedLibraryAtom(const SharedLibraryAtom &atom) { |
| 266 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 267 | << " SharedLibraryAtom: " |
| 268 | << llvm::format("0x%09lX", &atom) |
| 269 | << ", name=" |
| 270 | << atom.name() |
| 271 | << "\n"); |
| 272 | |
Nick Kledzik | 6bc04c6 | 2012-02-22 21:56:59 +0000 | [diff] [blame] | 273 | // add to list of known atoms |
| 274 | _atoms.push_back(&atom); |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 275 | |
Nick Kledzik | 6bc04c6 | 2012-02-22 21:56:59 +0000 | [diff] [blame] | 276 | // tell symbol table |
| 277 | _symbolTable.add(atom); |
| 278 | } |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 279 | |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 280 | void Resolver::doAbsoluteAtom(const AbsoluteAtom &atom) { |
| 281 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 282 | << " AbsoluteAtom: " |
| 283 | << llvm::format("0x%09lX", &atom) |
| 284 | << ", name=" |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 285 | << atom.name() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 286 | << "\n"); |
| 287 | |
Nick Kledzik | 6bc04c6 | 2012-02-22 21:56:59 +0000 | [diff] [blame] | 288 | // add to list of known atoms |
| 289 | _atoms.push_back(&atom); |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 290 | |
Nick Kledzik | 6bc04c6 | 2012-02-22 21:56:59 +0000 | [diff] [blame] | 291 | // tell symbol table |
Rui Ueyama | c53b3b0 | 2013-12-10 06:19:09 +0000 | [diff] [blame] | 292 | if (atom.scope() != Atom::scopeTranslationUnit) |
Hemant Kulkarni | f828613 | 2012-11-05 19:13:54 +0000 | [diff] [blame] | 293 | _symbolTable.add(atom); |
Nick Kledzik | 6bc04c6 | 2012-02-22 21:56:59 +0000 | [diff] [blame] | 294 | } |
| 295 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 296 | // utility to add a vector of atoms |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 297 | void Resolver::addAtoms(const std::vector<const DefinedAtom *> &newAtoms) { |
Rui Ueyama | c53b3b0 | 2013-12-10 06:19:09 +0000 | [diff] [blame] | 298 | for (const DefinedAtom *newAtom : newAtoms) |
Rui Ueyama | 90b3b92 | 2013-05-09 04:00:44 +0000 | [diff] [blame] | 299 | this->doDefinedAtom(*newAtom); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 300 | } |
| 301 | |
Rui Ueyama | 2ad117d | 2013-10-11 06:26:16 +0000 | [diff] [blame] | 302 | // Keep adding atoms until _context.nextFile() returns an error. This function |
| 303 | // is where undefined atoms are resolved. |
| 304 | bool Resolver::resolveUndefines() { |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 305 | ScopedTask task(getDefaultDomain(), "resolveUndefines"); |
Shankar Easwaran | eeee23e | 2013-04-11 02:56:30 +0000 | [diff] [blame] | 306 | |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 307 | for (;;) { |
Rui Ueyama | eb4b543 | 2014-04-02 05:03:40 +0000 | [diff] [blame^] | 308 | ErrorOr<File &> file = _context.inputGraph().nextFile(); |
| 309 | _context.inputGraph().setResolverState(Resolver::StateNoChange); |
Rafael Espindola | d28918b | 2014-01-08 22:00:09 +0000 | [diff] [blame] | 310 | error_code ec = file.getError(); |
| 311 | if (ec == InputGraphError::no_more_files) |
Rui Ueyama | 2ad117d | 2013-10-11 06:26:16 +0000 | [diff] [blame] | 312 | return true; |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 313 | if (!file) { |
| 314 | llvm::errs() << "Error occurred in nextFile: " |
Rafael Espindola | d28918b | 2014-01-08 22:00:09 +0000 | [diff] [blame] | 315 | << ec.message() << "\n"; |
Rui Ueyama | 2ad117d | 2013-10-11 06:26:16 +0000 | [diff] [blame] | 316 | return false; |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 317 | } |
| 318 | |
| 319 | switch (file->kind()) { |
| 320 | case File::kindObject: |
| 321 | assert(!file->hasOrdinal()); |
| 322 | file->setOrdinal(_context.getNextOrdinalAndIncrement()); |
| 323 | handleFile(*file); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 324 | break; |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 325 | case File::kindArchiveLibrary: |
| 326 | if (!file->hasOrdinal()) |
| 327 | file->setOrdinal(_context.getNextOrdinalAndIncrement()); |
| 328 | handleArchiveFile(*file); |
| 329 | break; |
| 330 | case File::kindSharedLibrary: |
| 331 | if (!file->hasOrdinal()) |
| 332 | file->setOrdinal(_context.getNextOrdinalAndIncrement()); |
| 333 | handleSharedLibrary(*file); |
| 334 | break; |
Shankar Easwaran | 1d3c48f | 2013-10-09 05:23:23 +0000 | [diff] [blame] | 335 | } |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 336 | } |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 337 | } |
| 338 | |
| 339 | // switch all references to undefined or coalesced away atoms |
| 340 | // to the new defined atom |
| 341 | void Resolver::updateReferences() { |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 342 | ScopedTask task(getDefaultDomain(), "updateReferences"); |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 343 | for (const Atom *atom : _atoms) { |
| 344 | if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom)) { |
Nick Kledzik | 062a98c | 2012-04-08 23:52:13 +0000 | [diff] [blame] | 345 | for (const Reference *ref : *defAtom) { |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 346 | const Atom *newTarget = _symbolTable.replacement(ref->target()); |
| 347 | const_cast<Reference *>(ref)->setTarget(newTarget); |
Nick Kledzik | 1a6615d | 2012-03-08 00:18:30 +0000 | [diff] [blame] | 348 | } |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 349 | } |
| 350 | } |
| 351 | } |
| 352 | |
Rui Ueyama | e5531fa | 2013-12-26 07:13:28 +0000 | [diff] [blame] | 353 | // For dead code stripping, recursively mark atoms "live" |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 354 | void Resolver::markLive(const Atom &atom) { |
Rui Ueyama | e5531fa | 2013-12-26 07:13:28 +0000 | [diff] [blame] | 355 | // Mark the atom is live. If it's already marked live, then stop recursion. |
| 356 | auto exists = _liveAtoms.insert(&atom); |
| 357 | if (!exists.second) |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 358 | return; |
| 359 | |
Rui Ueyama | e5531fa | 2013-12-26 07:13:28 +0000 | [diff] [blame] | 360 | // Mark all atoms it references as live |
Rui Ueyama | c481b5b | 2013-12-26 07:02:33 +0000 | [diff] [blame] | 361 | if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(&atom)) |
| 362 | for (const Reference *ref : *defAtom) |
| 363 | if (const Atom *target = ref->target()) |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 364 | this->markLive(*target); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 365 | } |
| 366 | |
| 367 | // remove all atoms not actually used |
Rui Ueyama | f3630fe | 2013-10-16 19:21:50 +0000 | [diff] [blame] | 368 | void Resolver::deadStripOptimize() { |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 369 | ScopedTask task(getDefaultDomain(), "deadStripOptimize"); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 370 | // only do this optimization with -dead_strip |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 371 | if (!_context.deadStrip()) |
Rui Ueyama | f3630fe | 2013-10-16 19:21:50 +0000 | [diff] [blame] | 372 | return; |
Rui Ueyama | 841016a | 2013-12-26 08:11:06 +0000 | [diff] [blame] | 373 | assert(_liveAtoms.empty()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 374 | |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 375 | // By default, shared libraries are built with all globals as dead strip roots |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 376 | if (_context.globalsAreDeadStripRoots()) { |
| 377 | for (const Atom *atom : _atoms) { |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 378 | const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom); |
| 379 | if (defAtom == nullptr) |
| 380 | continue; |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 381 | if (defAtom->scope() == DefinedAtom::scopeGlobal) |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 382 | _deadStripRoots.insert(defAtom); |
| 383 | } |
| 384 | } |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 385 | |
Joerg Sonnenberger | 03ed4cf | 2014-01-03 18:43:32 +0000 | [diff] [blame] | 386 | // Or, use list of names that are dead strip roots. |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 387 | for (const StringRef &name : _context.deadStripRoots()) { |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 388 | const Atom *symAtom = _symbolTable.findByName(name); |
Rui Ueyama | f3630fe | 2013-10-16 19:21:50 +0000 | [diff] [blame] | 389 | assert(symAtom); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 390 | _deadStripRoots.insert(symAtom); |
| 391 | } |
| 392 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 393 | // mark all roots as live, and recursively all atoms they reference |
Rui Ueyama | c53b3b0 | 2013-12-10 06:19:09 +0000 | [diff] [blame] | 394 | for (const Atom *dsrAtom : _deadStripRoots) |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 395 | this->markLive(*dsrAtom); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 396 | |
| 397 | // now remove all non-live atoms from _atoms |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 398 | _atoms.erase( |
| 399 | std::remove_if(_atoms.begin(), _atoms.end(), NotLive(_liveAtoms)), |
| 400 | _atoms.end()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 401 | } |
| 402 | |
| 403 | // error out if some undefines remain |
Rui Ueyama | d9696cb | 2014-01-18 00:27:03 +0000 | [diff] [blame] | 404 | bool Resolver::checkUndefines(bool isFinal) { |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 405 | // when using LTO, undefines are checked after bitcode is optimized |
Rui Ueyama | d9696cb | 2014-01-18 00:27:03 +0000 | [diff] [blame] | 406 | if (_haveLLVMObjs && !isFinal) |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 407 | return false; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 408 | |
| 409 | // build vector of remaining undefined symbols |
Michael J. Spencer | 280dadb | 2013-01-31 22:56:13 +0000 | [diff] [blame] | 410 | std::vector<const UndefinedAtom *> undefinedAtoms; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 411 | _symbolTable.undefines(undefinedAtoms); |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 412 | if (_context.deadStrip()) { |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 413 | // When dead code stripping, we don't care if dead atoms are undefined. |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 414 | undefinedAtoms.erase(std::remove_if(undefinedAtoms.begin(), |
| 415 | undefinedAtoms.end(), |
| 416 | NotLive(_liveAtoms)), |
| 417 | undefinedAtoms.end()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 418 | } |
| 419 | |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 420 | // error message about missing symbols |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 421 | if (!undefinedAtoms.empty()) { |
Shankar Easwaran | eeee23e | 2013-04-11 02:56:30 +0000 | [diff] [blame] | 422 | // FIXME: need diagnostics interface for writing error messages |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 423 | bool foundUndefines = false; |
Michael J. Spencer | 280dadb | 2013-01-31 22:56:13 +0000 | [diff] [blame] | 424 | for (const UndefinedAtom *undefAtom : undefinedAtoms) { |
Shankar Easwaran | eeee23e | 2013-04-11 02:56:30 +0000 | [diff] [blame] | 425 | const File &f = undefAtom->file(); |
Michael J. Spencer | 9d70cef | 2013-04-24 19:00:26 +0000 | [diff] [blame] | 426 | |
| 427 | // Skip over a weak symbol. |
| 428 | if (undefAtom->canBeNull() != UndefinedAtom::canBeNullNever) |
| 429 | continue; |
| 430 | |
| 431 | // If this is a library and undefined symbols are allowed on the |
| 432 | // target platform, skip over it. |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 433 | if (isa<SharedLibraryFile>(f) && _context.allowShlibUndefines()) |
Michael J. Spencer | 9d70cef | 2013-04-24 19:00:26 +0000 | [diff] [blame] | 434 | continue; |
| 435 | |
Rui Ueyama | 6f325496 | 2013-09-12 21:42:52 +0000 | [diff] [blame] | 436 | // If the undefine is coalesced away, skip over it. |
| 437 | if (_symbolTable.replacement(undefAtom) != undefAtom) |
| 438 | continue; |
| 439 | |
Michael J. Spencer | 9d70cef | 2013-04-24 19:00:26 +0000 | [diff] [blame] | 440 | // Seems like this symbol is undefined. Warn that. |
| 441 | foundUndefines = true; |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 442 | if (_context.printRemainingUndefines()) { |
Rui Ueyama | 8d7a6f2 | 2014-01-18 00:57:40 +0000 | [diff] [blame] | 443 | llvm::errs() << "Undefined symbol: " << undefAtom->file().path() |
| 444 | << ": " << undefAtom->name() << "\n"; |
Michael J. Spencer | 280dadb | 2013-01-31 22:56:13 +0000 | [diff] [blame] | 445 | } |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 446 | } |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 447 | if (foundUndefines) { |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 448 | if (_context.printRemainingUndefines()) |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 449 | llvm::errs() << "symbol(s) not found\n"; |
| 450 | return true; |
| 451 | } |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 452 | } |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 453 | return false; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 454 | } |
| 455 | |
| 456 | // remove from _atoms all coaleseced away atoms |
| 457 | void Resolver::removeCoalescedAwayAtoms() { |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 458 | ScopedTask task(getDefaultDomain(), "removeCoalescedAwayAtoms"); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 459 | _atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(), |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 460 | AtomCoalescedAway(_symbolTable)), |
| 461 | _atoms.end()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 462 | } |
| 463 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 464 | void Resolver::linkTimeOptimize() { |
| 465 | // FIX ME |
| 466 | } |
| 467 | |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 468 | bool Resolver::resolve() { |
Rui Ueyama | 2ad117d | 2013-10-11 06:26:16 +0000 | [diff] [blame] | 469 | if (!this->resolveUndefines()) |
| 470 | return false; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 471 | this->updateReferences(); |
Rui Ueyama | f3630fe | 2013-10-16 19:21:50 +0000 | [diff] [blame] | 472 | this->deadStripOptimize(); |
Rui Ueyama | c53b3b0 | 2013-12-10 06:19:09 +0000 | [diff] [blame] | 473 | if (this->checkUndefines(false)) |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 474 | if (!_context.allowRemainingUndefines()) |
Rui Ueyama | ee36604 | 2013-10-11 06:16:33 +0000 | [diff] [blame] | 475 | return false; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 476 | this->removeCoalescedAwayAtoms(); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 477 | this->linkTimeOptimize(); |
Shankar Easwaran | 2bc2492 | 2013-10-29 05:12:14 +0000 | [diff] [blame] | 478 | this->_result->addAtoms(_atoms); |
Rui Ueyama | ee36604 | 2013-10-11 06:16:33 +0000 | [diff] [blame] | 479 | return true; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 480 | } |
| 481 | |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 482 | void Resolver::MergedFile::addAtom(const Atom &atom) { |
Rui Ueyama | 251e68b | 2014-01-18 00:38:44 +0000 | [diff] [blame] | 483 | if (auto *def = dyn_cast<DefinedAtom>(&atom)) { |
| 484 | _definedAtoms._atoms.push_back(def); |
| 485 | } else if (auto *undef = dyn_cast<UndefinedAtom>(&atom)) { |
| 486 | _undefinedAtoms._atoms.push_back(undef); |
| 487 | } else if (auto *shared = dyn_cast<SharedLibraryAtom>(&atom)) { |
| 488 | _sharedLibraryAtoms._atoms.push_back(shared); |
| 489 | } else if (auto *abs = dyn_cast<AbsoluteAtom>(&atom)) { |
| 490 | _absoluteAtoms._atoms.push_back(abs); |
Michael J. Spencer | b495562 | 2012-04-02 23:56:36 +0000 | [diff] [blame] | 491 | } else { |
Nick Kledzik | 751eb3d | 2012-06-15 20:37:24 +0000 | [diff] [blame] | 492 | llvm_unreachable("atom has unknown definition kind"); |
Nick Kledzik | 1a6615d | 2012-03-08 00:18:30 +0000 | [diff] [blame] | 493 | } |
| 494 | } |
| 495 | |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 496 | MutableFile::DefinedAtomRange Resolver::MergedFile::definedAtoms() { |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 497 | return range<std::vector<const DefinedAtom *>::iterator>( |
| 498 | _definedAtoms._atoms.begin(), _definedAtoms._atoms.end()); |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 499 | } |
| 500 | |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 501 | void Resolver::MergedFile::addAtoms(std::vector<const Atom *> &all) { |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 502 | ScopedTask task(getDefaultDomain(), "addAtoms"); |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 503 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "Resolver final atom list:\n"); |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 504 | for (const Atom *atom : all) { |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 505 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
| 506 | << llvm::format(" 0x%09lX", atom) |
| 507 | << ", name=" |
| 508 | << atom->name() |
| 509 | << "\n"); |
Nick Kledzik | 062a98c | 2012-04-08 23:52:13 +0000 | [diff] [blame] | 510 | this->addAtom(*atom); |
Nick Kledzik | 1a6615d | 2012-03-08 00:18:30 +0000 | [diff] [blame] | 511 | } |
| 512 | } |
| 513 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 514 | } // namespace lld |