1 //===- lib/Linker/LinkArchives.cpp - Link LLVM objects and libraries ------===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains routines to handle linking together LLVM bytecode files,
11 // and to handle annoying things like static libraries.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/Linker.h"
16 #include "llvm/Module.h"
17 #include "llvm/ModuleProvider.h"
18 #include "llvm/ADT/SetOperations.h"
19 #include "llvm/Bytecode/Reader.h"
20 #include "llvm/Bytecode/Archive.h"
21 #include "llvm/Config/config.h"
28 /// GetAllDefinedSymbols - Modifies its parameter DefinedSymbols to contain the
29 /// name of each externally-visible symbol defined in M.
32 GetAllDefinedSymbols(Module *M, std::set<std::string> &DefinedSymbols) {
33 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
34 if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
35 DefinedSymbols.insert(I->getName());
36 for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
37 if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
38 DefinedSymbols.insert(I->getName());
41 /// GetAllUndefinedSymbols - calculates the set of undefined symbols that still
42 /// exist in an LLVM module. This is a bit tricky because there may be two
43 /// symbols with the same name but different LLVM types that will be resolved to
44 /// each other but aren't currently (thus we need to treat it as resolved).
47 /// M - The module in which to find undefined symbols.
50 /// UndefinedSymbols - A set of C++ strings containing the name of all
51 /// undefined symbols.
54 GetAllUndefinedSymbols(Module *M, std::set<std::string> &UndefinedSymbols) {
55 std::set<std::string> DefinedSymbols;
56 UndefinedSymbols.clear();
58 for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
61 UndefinedSymbols.insert(I->getName());
62 else if (!I->hasInternalLinkage())
63 DefinedSymbols.insert(I->getName());
65 for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
68 UndefinedSymbols.insert(I->getName());
69 else if (!I->hasInternalLinkage())
70 DefinedSymbols.insert(I->getName());
73 // Prune out any defined symbols from the undefined symbols set...
74 for (std::set<std::string>::iterator I = UndefinedSymbols.begin();
75 I != UndefinedSymbols.end(); )
76 if (DefinedSymbols.count(*I))
77 UndefinedSymbols.erase(I++); // This symbol really is defined!
79 ++I; // Keep this symbol in the undefined symbols list
82 /// LinkInArchive - opens an archive library and link in all objects which
83 /// provide symbols that are currently undefined.
86 /// Filename - The pathname of the archive.
89 /// TRUE - An error occurred.
90 /// FALSE - No errors.
92 Linker::LinkInArchive(const sys::Path &Filename) {
94 // Make sure this is an archive file we're dealing with
95 if (!Filename.isArchive())
96 return error("File '" + Filename.toString() + "' is not an archive.");
98 // Open the archive file
99 verbose("Linking archive file '" + Filename.toString() + "'");
101 // Find all of the symbols currently undefined in the bytecode program.
102 // If all the symbols are defined, the program is complete, and there is
103 // no reason to link in any archive files.
104 std::set<std::string> UndefinedSymbols;
105 GetAllUndefinedSymbols(Composite, UndefinedSymbols);
107 if (UndefinedSymbols.empty()) {
108 verbose("No symbols undefined, skipping library '" +
109 Filename.toString() + "'");
110 return false; // No need to link anything in!
114 std::auto_ptr<Archive> AutoArch (
115 Archive::OpenAndLoadSymbols(Filename,&ErrMsg));
117 Archive* arch = AutoArch.get();
120 return error("Cannot read archive '" + Filename.toString() +
123 // Save a set of symbols that are not defined by the archive. Since we're
124 // entering a loop, there's no point searching for these multiple times. This
125 // variable is used to "set_subtract" from the set of undefined symbols.
126 std::set<std::string> NotDefinedByArchive;
128 // While we are linking in object files, loop.
131 // Find the modules we need to link into the target module
132 std::set<ModuleProvider*> Modules;
133 arch->findModulesDefiningSymbols(UndefinedSymbols, Modules);
135 // If we didn't find any more modules to link this time, we are done
136 // searching this archive.
140 // Any symbols remaining in UndefinedSymbols after
141 // findModulesDefiningSymbols are ones that the archive does not define. So
142 // we add them to the NotDefinedByArchive variable now.
143 NotDefinedByArchive.insert(UndefinedSymbols.begin(),
144 UndefinedSymbols.end());
146 // Loop over all the ModuleProviders that we got back from the archive
147 for (std::set<ModuleProvider*>::iterator I=Modules.begin(), E=Modules.end();
150 // Get the module we must link in.
151 std::auto_ptr<Module> AutoModule( (*I)->releaseModule() );
152 Module* aModule = AutoModule.get();
154 verbose(" Linking in module: " + aModule->getModuleIdentifier());
157 if (LinkInModule(aModule))
158 return error("Cannot link in module '" +
159 aModule->getModuleIdentifier() + "': " + Error);
162 // Get the undefined symbols from the aggregate module. This recomputes the
163 // symbols we still need after the new modules have been linked in.
164 GetAllUndefinedSymbols(Composite, UndefinedSymbols);
166 // At this point we have two sets of undefined symbols: UndefinedSymbols
167 // which holds the undefined symbols from all the modules, and
168 // NotDefinedByArchive which holds symbols we know the archive doesn't
169 // define. There's no point searching for symbols that we won't find in the
170 // archive so we subtract these sets.
171 set_subtract(UndefinedSymbols, NotDefinedByArchive);
173 // If there's no symbols left, no point in continuing to search the
175 if (UndefinedSymbols.empty())