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" |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 13 | #include "lld/Core/Instrumentation.h" |
Michael J. Spencer | e6203a5 | 2012-04-03 18:39:40 +0000 | [diff] [blame] | 14 | #include "lld/Core/LLVM.h" |
Rui Ueyama | 0ca149f | 2013-08-06 22:31:59 +0000 | [diff] [blame] | 15 | #include "lld/Core/LinkingContext.h" |
Shankar Easwaran | 2b67fca | 2014-10-18 05:33:55 +0000 | [diff] [blame] | 16 | #include "lld/Core/Resolver.h" |
| 17 | #include "lld/Core/SharedLibraryFile.h" |
| 18 | #include "lld/Core/SymbolTable.h" |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 19 | #include "lld/Core/UndefinedAtom.h" |
Rui Ueyama | 25d5abd | 2015-03-06 00:22:48 +0000 | [diff] [blame] | 20 | #include "llvm/ADT/iterator_range.h" |
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" |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 25 | #include <algorithm> |
| 26 | #include <cassert> |
Rui Ueyama | 25d5abd | 2015-03-06 00:22:48 +0000 | [diff] [blame] | 27 | #include <utility> |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 28 | #include <vector> |
| 29 | |
| 30 | namespace lld { |
| 31 | |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 32 | ErrorOr<bool> Resolver::handleFile(File &file) { |
| 33 | if (auto ec = _ctx.handleLoadedFile(file)) |
| 34 | return ec; |
Rui Ueyama | 2a52251 | 2014-05-14 17:29:27 +0000 | [diff] [blame] | 35 | bool undefAdded = false; |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 36 | for (auto &atom : file.defined().owning_ptrs()) |
| 37 | doDefinedAtom(std::move(atom)); |
| 38 | for (auto &atom : file.undefined().owning_ptrs()) { |
| 39 | if (doUndefinedAtom(std::move(atom))) |
Rui Ueyama | 2a52251 | 2014-05-14 17:29:27 +0000 | [diff] [blame] | 40 | undefAdded = true; |
Rui Ueyama | 791db5f | 2015-03-03 22:19:46 +0000 | [diff] [blame] | 41 | } |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 42 | for (auto &atom : file.sharedLibrary().owning_ptrs()) |
| 43 | doSharedLibraryAtom(std::move(atom)); |
| 44 | for (auto &atom : file.absolute().owning_ptrs()) |
| 45 | doAbsoluteAtom(std::move(atom)); |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 46 | return undefAdded; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 47 | } |
| 48 | |
Rui Ueyama | 46a8e29 | 2016-03-28 20:59:47 +0000 | [diff] [blame] | 49 | ErrorOr<bool> Resolver::forEachUndefines(File &file, UndefCallback callback) { |
Rui Ueyama | 13003d7 | 2015-03-06 00:28:41 +0000 | [diff] [blame] | 50 | size_t i = _undefineIndex[&file]; |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 51 | bool undefAdded = false; |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 52 | do { |
Rui Ueyama | 13003d7 | 2015-03-06 00:28:41 +0000 | [diff] [blame] | 53 | for (; i < _undefines.size(); ++i) { |
| 54 | StringRef undefName = _undefines[i]; |
| 55 | if (undefName.empty()) |
| 56 | continue; |
Rui Ueyama | 803150c | 2015-03-08 21:31:38 +0000 | [diff] [blame] | 57 | const Atom *atom = _symbolTable.findByName(undefName); |
| 58 | if (!isa<UndefinedAtom>(atom) || _symbolTable.isCoalescedAway(atom)) { |
Rui Ueyama | 13003d7 | 2015-03-06 00:28:41 +0000 | [diff] [blame] | 59 | // The symbol was resolved by some other file. Cache the result. |
| 60 | _undefines[i] = ""; |
| 61 | continue; |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 62 | } |
Rui Ueyama | 46a8e29 | 2016-03-28 20:59:47 +0000 | [diff] [blame] | 63 | auto undefAddedOrError = callback(undefName); |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 64 | if (undefAddedOrError.getError()) |
| 65 | return undefAddedOrError; |
| 66 | undefAdded |= undefAddedOrError.get(); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 67 | } |
Rui Ueyama | 13003d7 | 2015-03-06 00:28:41 +0000 | [diff] [blame] | 68 | } while (i < _undefines.size()); |
| 69 | _undefineIndex[&file] = i; |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 70 | return undefAdded; |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 71 | } |
| 72 | |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 73 | ErrorOr<bool> Resolver::handleArchiveFile(File &file) { |
Rui Ueyama | 394d10e | 2015-03-04 04:36:46 +0000 | [diff] [blame] | 74 | ArchiveLibraryFile *archiveFile = cast<ArchiveLibraryFile>(&file); |
Rui Ueyama | 46a8e29 | 2016-03-28 20:59:47 +0000 | [diff] [blame] | 75 | return forEachUndefines(file, [&](StringRef undefName) -> ErrorOr<bool> { |
| 76 | if (File *member = archiveFile->find(undefName)) { |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 77 | member->setOrdinal(_ctx.getNextOrdinalAndIncrement()); |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 78 | return handleFile(*member); |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 79 | } |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 80 | return false; |
Rui Ueyama | 0b8e053 | 2014-04-04 00:39:37 +0000 | [diff] [blame] | 81 | }); |
Rui Ueyama | 3429d01 | 2013-11-15 04:58:54 +0000 | [diff] [blame] | 82 | } |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 83 | |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 84 | std::error_code Resolver::handleSharedLibrary(File &file) { |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 85 | // Add all the atoms from the shared library |
Rui Ueyama | 394d10e | 2015-03-04 04:36:46 +0000 | [diff] [blame] | 86 | SharedLibraryFile *sharedLibrary = cast<SharedLibraryFile>(&file); |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 87 | auto undefAddedOrError = handleFile(*sharedLibrary); |
| 88 | if (undefAddedOrError.getError()) |
| 89 | return undefAddedOrError.getError(); |
Rui Ueyama | 46a8e29 | 2016-03-28 20:59:47 +0000 | [diff] [blame] | 90 | undefAddedOrError = |
| 91 | forEachUndefines(file, [&](StringRef undefName) -> ErrorOr<bool> { |
| 92 | auto atom = sharedLibrary->exports(undefName); |
| 93 | if (atom.get()) |
| 94 | doSharedLibraryAtom(std::move(atom)); |
| 95 | return false; |
| 96 | }); |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 97 | |
| 98 | if (undefAddedOrError.getError()) |
| 99 | return undefAddedOrError.getError(); |
| 100 | return std::error_code(); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 101 | } |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 102 | |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 103 | bool Resolver::doUndefinedAtom(OwningAtomPtr<UndefinedAtom> atom) { |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 104 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
| 105 | << " UndefinedAtom: " |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 106 | << llvm::format("0x%09lX", atom.get()) |
| 107 | << ", name=" << atom.get()->name() << "\n"); |
Pete Cooper | 3e4d732 | 2016-03-22 04:00:41 +0000 | [diff] [blame] | 108 | |
| 109 | // tell symbol table |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 110 | bool newUndefAdded = _symbolTable.add(*atom.get()); |
Pete Cooper | 3e4d732 | 2016-03-22 04:00:41 +0000 | [diff] [blame] | 111 | if (newUndefAdded) |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 112 | _undefines.push_back(atom.get()->name()); |
| 113 | |
| 114 | // add to list of known atoms |
| 115 | _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); |
Rui Ueyama | 70625fb | 2014-04-03 22:21:59 +0000 | [diff] [blame] | 116 | |
Rui Ueyama | 2a52251 | 2014-05-14 17:29:27 +0000 | [diff] [blame] | 117 | return newUndefAdded; |
Nick Kledzik | f4fb2c5 | 2012-01-11 01:06:19 +0000 | [diff] [blame] | 118 | } |
| 119 | |
Rui Ueyama | 2a52251 | 2014-05-14 17:29:27 +0000 | [diff] [blame] | 120 | // Called on each atom when a file is added. Returns true if a given |
| 121 | // atom is added to the symbol table. |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 122 | void Resolver::doDefinedAtom(OwningAtomPtr<DefinedAtom> atom) { |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 123 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
| 124 | << " DefinedAtom: " |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 125 | << llvm::format("0x%09lX", atom.get()) |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 126 | << ", file=#" |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 127 | << atom.get()->file().ordinal() |
Nick Kledzik | 36293f6 | 2013-01-23 22:32:56 +0000 | [diff] [blame] | 128 | << ", atom=#" |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 129 | << atom.get()->ordinal() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 130 | << ", name=" |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 131 | << atom.get()->name() |
Pete Cooper | e5fa5a3 | 2015-12-16 22:03:21 +0000 | [diff] [blame] | 132 | << ", type=" |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 133 | << atom.get()->contentType() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 134 | << "\n"); |
| 135 | |
Rui Ueyama | 83e6acc | 2014-04-03 21:11:22 +0000 | [diff] [blame] | 136 | // An atom that should never be dead-stripped is a dead-strip root. |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 137 | if (_ctx.deadStrip() && |
| 138 | atom.get()->deadStrip() == DefinedAtom::deadStripNever) { |
| 139 | _deadStripRoots.insert(atom.get()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 140 | } |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 141 | |
| 142 | // add to list of known atoms |
| 143 | _symbolTable.add(*atom.get()); |
| 144 | _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 145 | } |
| 146 | |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 147 | void Resolver::doSharedLibraryAtom(OwningAtomPtr<SharedLibraryAtom> atom) { |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 148 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 149 | << " SharedLibraryAtom: " |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 150 | << llvm::format("0x%09lX", atom.get()) |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 151 | << ", name=" |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 152 | << atom.get()->name() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 153 | << "\n"); |
| 154 | |
Pete Cooper | 3e4d732 | 2016-03-22 04:00:41 +0000 | [diff] [blame] | 155 | // tell symbol table |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 156 | _symbolTable.add(*atom.get()); |
| 157 | |
| 158 | // add to list of known atoms |
| 159 | _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); |
Nick Kledzik | 6bc04c6 | 2012-02-22 21:56:59 +0000 | [diff] [blame] | 160 | } |
Michael J. Spencer | 765792d | 2012-04-03 18:40:27 +0000 | [diff] [blame] | 161 | |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 162 | void Resolver::doAbsoluteAtom(OwningAtomPtr<AbsoluteAtom> atom) { |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 163 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 164 | << " AbsoluteAtom: " |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 165 | << llvm::format("0x%09lX", atom.get()) |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 166 | << ", name=" |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 167 | << atom.get()->name() |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 168 | << "\n"); |
| 169 | |
Pete Cooper | 3e4d732 | 2016-03-22 04:00:41 +0000 | [diff] [blame] | 170 | // tell symbol table |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 171 | if (atom.get()->scope() != Atom::scopeTranslationUnit) |
| 172 | _symbolTable.add(*atom.get()); |
Pete Cooper | 3e4d732 | 2016-03-22 04:00:41 +0000 | [diff] [blame] | 173 | |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 174 | // add to list of known atoms |
| 175 | _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 176 | } |
| 177 | |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 178 | // Returns true if at least one of N previous files has created an |
| 179 | // undefined symbol. |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 180 | bool Resolver::undefinesAdded(int begin, int end) { |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 181 | std::vector<std::unique_ptr<Node>> &inputs = _ctx.getNodes(); |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 182 | for (int i = begin; i < end; ++i) |
| 183 | if (FileNode *node = dyn_cast<FileNode>(inputs[i].get())) |
| 184 | if (_newUndefinesAdded[node->getFile()]) |
Rui Ueyama | d4730ea | 2015-01-16 15:54:13 +0000 | [diff] [blame] | 185 | return true; |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 186 | return false; |
| 187 | } |
| 188 | |
Rui Ueyama | bcf8918 | 2015-01-21 18:54:26 +0000 | [diff] [blame] | 189 | File *Resolver::getFile(int &index) { |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 190 | std::vector<std::unique_ptr<Node>> &inputs = _ctx.getNodes(); |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 191 | if ((size_t)index >= inputs.size()) |
| 192 | return nullptr; |
| 193 | if (GroupEnd *group = dyn_cast<GroupEnd>(inputs[index].get())) { |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 194 | // We are at the end of the current group. If one or more new |
| 195 | // undefined atom has been added in the last groupSize files, we |
| 196 | // reiterate over the files. |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 197 | int size = group->getSize(); |
| 198 | if (undefinesAdded(index - size, index)) { |
| 199 | index -= size; |
Rui Ueyama | bcf8918 | 2015-01-21 18:54:26 +0000 | [diff] [blame] | 200 | return getFile(index); |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 201 | } |
| 202 | ++index; |
Rui Ueyama | bcf8918 | 2015-01-21 18:54:26 +0000 | [diff] [blame] | 203 | return getFile(index); |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 204 | } |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 205 | return cast<FileNode>(inputs[index++].get())->getFile(); |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 206 | } |
| 207 | |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 208 | // Keep adding atoms until _ctx.getNextFile() returns an error. This |
Rui Ueyama | 8bd093b | 2014-04-04 00:14:04 +0000 | [diff] [blame] | 209 | // function is where undefined atoms are resolved. |
Rui Ueyama | d4730ea | 2015-01-16 15:54:13 +0000 | [diff] [blame] | 210 | bool Resolver::resolveUndefines() { |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 211 | DEBUG_WITH_TYPE("resolver", |
| 212 | llvm::dbgs() << "******** Resolving undefines:\n"); |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 213 | ScopedTask task(getDefaultDomain(), "resolveUndefines"); |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 214 | int index = 0; |
Rui Ueyama | bcf8918 | 2015-01-21 18:54:26 +0000 | [diff] [blame] | 215 | std::set<File *> seen; |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 216 | for (;;) { |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 217 | bool undefAdded = false; |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 218 | DEBUG_WITH_TYPE("resolver", |
| 219 | llvm::dbgs() << "Loading file #" << index << "\n"); |
Rui Ueyama | bcf8918 | 2015-01-21 18:54:26 +0000 | [diff] [blame] | 220 | File *file = getFile(index); |
Rui Ueyama | e9b4551 | 2014-12-14 02:04:01 +0000 | [diff] [blame] | 221 | if (!file) |
Rui Ueyama | d4730ea | 2015-01-16 15:54:13 +0000 | [diff] [blame] | 222 | return true; |
| 223 | if (std::error_code ec = file->parse()) { |
| 224 | llvm::errs() << "Cannot open " + file->path() |
| 225 | << ": " << ec.message() << "\n"; |
| 226 | return false; |
| 227 | } |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 228 | DEBUG_WITH_TYPE("resolver", |
| 229 | llvm::dbgs() << "Loaded file: " << file->path() << "\n"); |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 230 | switch (file->kind()) { |
Pete Cooper | f0c0f3c | 2016-01-14 22:55:38 +0000 | [diff] [blame] | 231 | case File::kindErrorObject: |
| 232 | case File::kindNormalizedObject: |
| 233 | case File::kindMachObject: |
Pete Cooper | f0c0f3c | 2016-01-14 22:55:38 +0000 | [diff] [blame] | 234 | case File::kindCEntryObject: |
Pete Cooper | d4f4145 | 2016-02-02 21:37:15 +0000 | [diff] [blame] | 235 | case File::kindHeaderObject: |
Pete Cooper | f0c0f3c | 2016-01-14 22:55:38 +0000 | [diff] [blame] | 236 | case File::kindEntryObject: |
| 237 | case File::kindUndefinedSymsObject: |
Pete Cooper | f0c0f3c | 2016-01-14 22:55:38 +0000 | [diff] [blame] | 238 | case File::kindStubHelperObject: |
| 239 | case File::kindResolverMergedObject: |
| 240 | case File::kindSectCreateObject: { |
Rui Ueyama | bcf8918 | 2015-01-21 18:54:26 +0000 | [diff] [blame] | 241 | // The same file may be visited more than once if the file is |
| 242 | // in --start-group and --end-group. Only library files should |
| 243 | // be processed more than once. |
| 244 | if (seen.count(file)) |
Rui Ueyama | 00eb257 | 2014-12-10 00:33:00 +0000 | [diff] [blame] | 245 | break; |
Rui Ueyama | bcf8918 | 2015-01-21 18:54:26 +0000 | [diff] [blame] | 246 | seen.insert(file); |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 247 | assert(!file->hasOrdinal()); |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 248 | file->setOrdinal(_ctx.getNextOrdinalAndIncrement()); |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 249 | auto undefAddedOrError = handleFile(*file); |
| 250 | if (undefAddedOrError.getError()) { |
| 251 | llvm::errs() << "Error in " + file->path() |
| 252 | << ": " << undefAddedOrError.getError().message() << "\n"; |
| 253 | return false; |
| 254 | } |
| 255 | undefAdded = undefAddedOrError.get(); |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 256 | break; |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 257 | } |
| 258 | case File::kindArchiveLibrary: { |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 259 | if (!file->hasOrdinal()) |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 260 | file->setOrdinal(_ctx.getNextOrdinalAndIncrement()); |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 261 | auto undefAddedOrError = handleArchiveFile(*file); |
| 262 | if (undefAddedOrError.getError()) { |
| 263 | llvm::errs() << "Error in " + file->path() |
| 264 | << ": " << undefAddedOrError.getError().message() << "\n"; |
| 265 | return false; |
| 266 | } |
| 267 | undefAdded = undefAddedOrError.get(); |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 268 | break; |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 269 | } |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 270 | case File::kindSharedLibrary: |
| 271 | if (!file->hasOrdinal()) |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 272 | file->setOrdinal(_ctx.getNextOrdinalAndIncrement()); |
Pete Cooper | 80c0974 | 2016-01-14 21:53:13 +0000 | [diff] [blame] | 273 | if (auto EC = handleSharedLibrary(*file)) { |
| 274 | llvm::errs() << "Error in " + file->path() |
| 275 | << ": " << EC.message() << "\n"; |
| 276 | return false; |
| 277 | } |
Rui Ueyama | d542b9e | 2013-10-11 03:48:06 +0000 | [diff] [blame] | 278 | break; |
Shankar Easwaran | 1d3c48f | 2013-10-09 05:23:23 +0000 | [diff] [blame] | 279 | } |
Rui Ueyama | 80c0443 | 2015-01-15 06:49:21 +0000 | [diff] [blame] | 280 | _newUndefinesAdded[file] = undefAdded; |
Shankar Easwaran | a96f3a3 | 2013-10-07 02:47:09 +0000 | [diff] [blame] | 281 | } |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 282 | } |
| 283 | |
| 284 | // switch all references to undefined or coalesced away atoms |
| 285 | // to the new defined atom |
| 286 | void Resolver::updateReferences() { |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 287 | DEBUG_WITH_TYPE("resolver", |
| 288 | llvm::dbgs() << "******** Updating references:\n"); |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 289 | ScopedTask task(getDefaultDomain(), "updateReferences"); |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 290 | for (const OwningAtomPtr<Atom> &atom : _atoms) { |
| 291 | if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom.get())) { |
Nick Kledzik | 062a98c | 2012-04-08 23:52:13 +0000 | [diff] [blame] | 292 | for (const Reference *ref : *defAtom) { |
Rui Ueyama | 61d7f97 | 2014-06-17 16:19:33 +0000 | [diff] [blame] | 293 | // A reference of type kindAssociate should't be updated. |
| 294 | // Instead, an atom having such reference will be removed |
| 295 | // if the target atom is coalesced away, so that they will |
| 296 | // go away as a group. |
| 297 | if (ref->kindNamespace() == lld::Reference::KindNamespace::all && |
| 298 | ref->kindValue() == lld::Reference::kindAssociate) { |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 299 | if (_symbolTable.isCoalescedAway(atom.get())) |
Rui Ueyama | 61d7f97 | 2014-06-17 16:19:33 +0000 | [diff] [blame] | 300 | _deadAtoms.insert(ref->target()); |
| 301 | continue; |
| 302 | } |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 303 | const Atom *newTarget = _symbolTable.replacement(ref->target()); |
| 304 | const_cast<Reference *>(ref)->setTarget(newTarget); |
Nick Kledzik | 1a6615d | 2012-03-08 00:18:30 +0000 | [diff] [blame] | 305 | } |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 306 | } |
| 307 | } |
| 308 | } |
| 309 | |
Rui Ueyama | e5531fa | 2013-12-26 07:13:28 +0000 | [diff] [blame] | 310 | // For dead code stripping, recursively mark atoms "live" |
Rui Ueyama | 6ffe42e | 2014-06-02 08:06:57 +0000 | [diff] [blame] | 311 | void Resolver::markLive(const Atom *atom) { |
Rui Ueyama | e5531fa | 2013-12-26 07:13:28 +0000 | [diff] [blame] | 312 | // Mark the atom is live. If it's already marked live, then stop recursion. |
Rui Ueyama | 6ffe42e | 2014-06-02 08:06:57 +0000 | [diff] [blame] | 313 | auto exists = _liveAtoms.insert(atom); |
Rui Ueyama | e5531fa | 2013-12-26 07:13:28 +0000 | [diff] [blame] | 314 | if (!exists.second) |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 315 | return; |
| 316 | |
Rui Ueyama | e5531fa | 2013-12-26 07:13:28 +0000 | [diff] [blame] | 317 | // Mark all atoms it references as live |
Rui Ueyama | 23487e8 | 2014-06-03 01:59:02 +0000 | [diff] [blame] | 318 | if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom)) { |
Rui Ueyama | c481b5b | 2013-12-26 07:02:33 +0000 | [diff] [blame] | 319 | for (const Reference *ref : *defAtom) |
Rui Ueyama | 6ffe42e | 2014-06-02 08:06:57 +0000 | [diff] [blame] | 320 | markLive(ref->target()); |
Rui Ueyama | 25d5abd | 2015-03-06 00:22:48 +0000 | [diff] [blame] | 321 | for (auto &p : llvm::make_range(_reverseRef.equal_range(defAtom))) { |
| 322 | const Atom *target = p.second; |
Rui Ueyama | d20d44f | 2014-09-26 23:21:10 +0000 | [diff] [blame] | 323 | markLive(target); |
Rui Ueyama | 25d5abd | 2015-03-06 00:22:48 +0000 | [diff] [blame] | 324 | } |
Rui Ueyama | 23487e8 | 2014-06-03 01:59:02 +0000 | [diff] [blame] | 325 | } |
| 326 | } |
| 327 | |
| 328 | static bool isBackref(const Reference *ref) { |
Rui Ueyama | 9aee050 | 2014-06-03 03:07:49 +0000 | [diff] [blame] | 329 | if (ref->kindNamespace() != lld::Reference::KindNamespace::all) |
| 330 | return false; |
Rafael Espindola | fd14979 | 2016-02-28 16:03:37 +0000 | [diff] [blame] | 331 | return (ref->kindValue() == lld::Reference::kindLayoutAfter); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | // remove all atoms not actually used |
Rui Ueyama | f3630fe | 2013-10-16 19:21:50 +0000 | [diff] [blame] | 335 | void Resolver::deadStripOptimize() { |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 336 | DEBUG_WITH_TYPE("resolver", |
| 337 | llvm::dbgs() << "******** Dead stripping unused atoms:\n"); |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 338 | ScopedTask task(getDefaultDomain(), "deadStripOptimize"); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 339 | // only do this optimization with -dead_strip |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 340 | if (!_ctx.deadStrip()) |
Rui Ueyama | f3630fe | 2013-10-16 19:21:50 +0000 | [diff] [blame] | 341 | return; |
Rui Ueyama | 23487e8 | 2014-06-03 01:59:02 +0000 | [diff] [blame] | 342 | |
| 343 | // Some type of references prevent referring atoms to be dead-striped. |
| 344 | // Make a reverse map of such references before traversing the graph. |
Davide Italiano | a82ae91 | 2015-02-26 05:39:57 +0000 | [diff] [blame] | 345 | // While traversing the list of atoms, mark AbsoluteAtoms as live |
| 346 | // in order to avoid reclaim. |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 347 | for (const OwningAtomPtr<Atom> &atom : _atoms) { |
| 348 | if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom.get())) |
Rui Ueyama | 23487e8 | 2014-06-03 01:59:02 +0000 | [diff] [blame] | 349 | for (const Reference *ref : *defAtom) |
| 350 | if (isBackref(ref)) |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 351 | _reverseRef.insert(std::make_pair(ref->target(), atom.get())); |
| 352 | if (const AbsoluteAtom *absAtom = dyn_cast<AbsoluteAtom>(atom.get())) |
Davide Italiano | a82ae91 | 2015-02-26 05:39:57 +0000 | [diff] [blame] | 353 | markLive(absAtom); |
| 354 | } |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 355 | |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 356 | // By default, shared libraries are built with all globals as dead strip roots |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 357 | if (_ctx.globalsAreDeadStripRoots()) |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 358 | for (const OwningAtomPtr<Atom> &atom : _atoms) |
| 359 | if (const DefinedAtom *defAtom = dyn_cast<DefinedAtom>(atom.get())) |
Rui Ueyama | 517f0d9 | 2014-04-03 21:16:37 +0000 | [diff] [blame] | 360 | if (defAtom->scope() == DefinedAtom::scopeGlobal) |
| 361 | _deadStripRoots.insert(defAtom); |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 362 | |
Joerg Sonnenberger | 03ed4cf | 2014-01-03 18:43:32 +0000 | [diff] [blame] | 363 | // Or, use list of names that are dead strip roots. |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 364 | for (const StringRef &name : _ctx.deadStripRoots()) { |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 365 | const Atom *symAtom = _symbolTable.findByName(name); |
Rui Ueyama | f3630fe | 2013-10-16 19:21:50 +0000 | [diff] [blame] | 366 | assert(symAtom); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 367 | _deadStripRoots.insert(symAtom); |
| 368 | } |
| 369 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 370 | // mark all roots as live, and recursively all atoms they reference |
Rui Ueyama | c53b3b0 | 2013-12-10 06:19:09 +0000 | [diff] [blame] | 371 | for (const Atom *dsrAtom : _deadStripRoots) |
Rui Ueyama | 6ffe42e | 2014-06-02 08:06:57 +0000 | [diff] [blame] | 372 | markLive(dsrAtom); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 373 | |
| 374 | // now remove all non-live atoms from _atoms |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 375 | _atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(), |
| 376 | [&](OwningAtomPtr<Atom> &a) { |
| 377 | return _liveAtoms.count(a.get()) == 0; |
Rui Ueyama | 450d987 | 2014-04-03 22:24:40 +0000 | [diff] [blame] | 378 | }), |
| 379 | _atoms.end()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 380 | } |
| 381 | |
| 382 | // error out if some undefines remain |
Rui Ueyama | 43a589c | 2014-04-02 06:38:46 +0000 | [diff] [blame] | 383 | bool Resolver::checkUndefines() { |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 384 | DEBUG_WITH_TYPE("resolver", |
| 385 | llvm::dbgs() << "******** Checking for undefines:\n"); |
| 386 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 387 | // build vector of remaining undefined symbols |
Rui Ueyama | 8dc9f0a | 2014-04-04 00:15:52 +0000 | [diff] [blame] | 388 | std::vector<const UndefinedAtom *> undefinedAtoms = _symbolTable.undefines(); |
Rui Ueyama | b2e1697 | 2015-02-27 23:40:00 +0000 | [diff] [blame] | 389 | if (_ctx.deadStrip()) { |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 390 | // When dead code stripping, we don't care if dead atoms are undefined. |
Rui Ueyama | 450d987 | 2014-04-03 22:24:40 +0000 | [diff] [blame] | 391 | undefinedAtoms.erase( |
| 392 | std::remove_if(undefinedAtoms.begin(), undefinedAtoms.end(), |
| 393 | [&](const Atom *a) { return _liveAtoms.count(a) == 0; }), |
| 394 | undefinedAtoms.end()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 395 | } |
| 396 | |
Rui Ueyama | 6780cea | 2015-03-05 20:22:14 +0000 | [diff] [blame] | 397 | if (undefinedAtoms.empty()) |
| 398 | return false; |
Michael J. Spencer | 9d70cef | 2013-04-24 19:00:26 +0000 | [diff] [blame] | 399 | |
Rui Ueyama | 6780cea | 2015-03-05 20:22:14 +0000 | [diff] [blame] | 400 | // Warn about unresolved symbols. |
| 401 | bool foundUndefines = false; |
| 402 | for (const UndefinedAtom *undef : undefinedAtoms) { |
| 403 | // Skip over a weak symbol. |
| 404 | if (undef->canBeNull() != UndefinedAtom::canBeNullNever) |
| 405 | continue; |
Michael J. Spencer | 9d70cef | 2013-04-24 19:00:26 +0000 | [diff] [blame] | 406 | |
Rui Ueyama | 6780cea | 2015-03-05 20:22:14 +0000 | [diff] [blame] | 407 | // If this is a library and undefined symbols are allowed on the |
| 408 | // target platform, skip over it. |
| 409 | if (isa<SharedLibraryFile>(undef->file()) && _ctx.allowShlibUndefines()) |
| 410 | continue; |
Rui Ueyama | 6f325496 | 2013-09-12 21:42:52 +0000 | [diff] [blame] | 411 | |
Rui Ueyama | 6780cea | 2015-03-05 20:22:14 +0000 | [diff] [blame] | 412 | // If the undefine is coalesced away, skip over it. |
| 413 | if (_symbolTable.isCoalescedAway(undef)) |
| 414 | continue; |
| 415 | |
| 416 | // Seems like this symbol is undefined. Warn that. |
| 417 | foundUndefines = true; |
| 418 | if (_ctx.printRemainingUndefines()) { |
| 419 | llvm::errs() << "Undefined symbol: " << undef->file().path() |
| 420 | << ": " << _ctx.demangle(undef->name()) |
| 421 | << "\n"; |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 422 | } |
Nick Kledzik | bb963df | 2012-04-18 21:55:06 +0000 | [diff] [blame] | 423 | } |
Rui Ueyama | 6780cea | 2015-03-05 20:22:14 +0000 | [diff] [blame] | 424 | if (!foundUndefines) |
| 425 | return false; |
| 426 | if (_ctx.printRemainingUndefines()) |
| 427 | llvm::errs() << "symbol(s) not found\n"; |
| 428 | return true; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | // remove from _atoms all coaleseced away atoms |
| 432 | void Resolver::removeCoalescedAwayAtoms() { |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 433 | DEBUG_WITH_TYPE("resolver", |
| 434 | llvm::dbgs() << "******** Removing coalesced away atoms:\n"); |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 435 | ScopedTask task(getDefaultDomain(), "removeCoalescedAwayAtoms"); |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 436 | _atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(), |
| 437 | [&](OwningAtomPtr<Atom> &a) { |
| 438 | return _symbolTable.isCoalescedAway(a.get()) || |
| 439 | _deadAtoms.count(a.get()); |
Rui Ueyama | 733b45f | 2014-06-05 07:37:29 +0000 | [diff] [blame] | 440 | }), |
Rui Ueyama | fd133b3 | 2013-11-21 23:41:53 +0000 | [diff] [blame] | 441 | _atoms.end()); |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 442 | } |
| 443 | |
Nick Kledzik | c314b46 | 2013-04-04 18:59:24 +0000 | [diff] [blame] | 444 | bool Resolver::resolve() { |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 445 | DEBUG_WITH_TYPE("resolver", |
| 446 | llvm::dbgs() << "******** Resolving atom references:\n"); |
Rui Ueyama | d4730ea | 2015-01-16 15:54:13 +0000 | [diff] [blame] | 447 | if (!resolveUndefines()) |
| 448 | return false; |
Rui Ueyama | 2b2ac91 | 2014-04-03 18:13:14 +0000 | [diff] [blame] | 449 | updateReferences(); |
| 450 | deadStripOptimize(); |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 451 | if (checkUndefines()) { |
| 452 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "Found undefines... "); |
| 453 | if (!_ctx.allowRemainingUndefines()) { |
| 454 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "which we don't allow\n"); |
Rui Ueyama | ee36604 | 2013-10-11 06:16:33 +0000 | [diff] [blame] | 455 | return false; |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 456 | } |
| 457 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "which we are ok with\n"); |
| 458 | } |
Rui Ueyama | 2b2ac91 | 2014-04-03 18:13:14 +0000 | [diff] [blame] | 459 | removeCoalescedAwayAtoms(); |
| 460 | _result->addAtoms(_atoms); |
Pete Cooper | 3e8f565 | 2015-12-16 19:12:49 +0000 | [diff] [blame] | 461 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "******** Finished resolver\n"); |
Rui Ueyama | ee36604 | 2013-10-11 06:16:33 +0000 | [diff] [blame] | 462 | return true; |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 463 | } |
| 464 | |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 465 | void Resolver::MergedFile::addAtoms( |
| 466 | llvm::MutableArrayRef<OwningAtomPtr<Atom>> all) { |
Michael J. Spencer | bd66d04 | 2013-05-28 18:55:39 +0000 | [diff] [blame] | 467 | ScopedTask task(getDefaultDomain(), "addAtoms"); |
Nick Kledzik | abb6981 | 2012-05-31 22:34:00 +0000 | [diff] [blame] | 468 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() << "Resolver final atom list:\n"); |
Pete Cooper | e5fa5a3 | 2015-12-16 22:03:21 +0000 | [diff] [blame] | 469 | |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 470 | for (OwningAtomPtr<Atom> &atom : all) { |
Pete Cooper | e5fa5a3 | 2015-12-16 22:03:21 +0000 | [diff] [blame] | 471 | #ifndef NDEBUG |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 472 | if (auto *definedAtom = dyn_cast<DefinedAtom>(atom.get())) { |
Pete Cooper | e5fa5a3 | 2015-12-16 22:03:21 +0000 | [diff] [blame] | 473 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 474 | << llvm::format(" 0x%09lX", definedAtom) |
Pete Cooper | e5fa5a3 | 2015-12-16 22:03:21 +0000 | [diff] [blame] | 475 | << ", file=#" |
| 476 | << definedAtom->file().ordinal() |
| 477 | << ", atom=#" |
| 478 | << definedAtom->ordinal() |
| 479 | << ", name=" |
| 480 | << definedAtom->name() |
| 481 | << ", type=" |
| 482 | << definedAtom->contentType() |
| 483 | << "\n"); |
| 484 | } else { |
| 485 | DEBUG_WITH_TYPE("resolver", llvm::dbgs() |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 486 | << llvm::format(" 0x%09lX", atom.get()) |
Pete Cooper | e5fa5a3 | 2015-12-16 22:03:21 +0000 | [diff] [blame] | 487 | << ", name=" |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 488 | << atom.get()->name() |
Pete Cooper | e5fa5a3 | 2015-12-16 22:03:21 +0000 | [diff] [blame] | 489 | << "\n"); |
| 490 | } |
| 491 | #endif |
Pete Cooper | 8ad55fb | 2016-03-22 17:15:50 +0000 | [diff] [blame] | 492 | addAtom(*atom.release()); |
Nick Kledzik | 1a6615d | 2012-03-08 00:18:30 +0000 | [diff] [blame] | 493 | } |
| 494 | } |
| 495 | |
Michael J. Spencer | 773a8fb | 2011-12-18 08:27:59 +0000 | [diff] [blame] | 496 | } // namespace lld |