• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- lib/Linker/LinkItems.cpp - Link LLVM objects and libraries ---------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains routines to handle linking together LLVM bitcode files,
11 // and to handle annoying things like static libraries.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/Linker.h"
16 #include "llvm/Module.h"
17 #include "llvm/Bitcode/ReaderWriter.h"
18 #include "llvm/Support/Path.h"
19 #include "llvm/Support/ErrorHandling.h"
20 #include "llvm/Support/MemoryBuffer.h"
21 #include "llvm/Support/system_error.h"
22 using namespace llvm;
23 
24 // LinkItems - This function is the main entry point into linking. It takes a
25 // list of LinkItem which indicates the order the files should be linked and
26 // how each file should be treated (plain file or with library search). The
27 // function only links bitcode and produces a result list of items that are
28 // native objects.
29 bool
LinkInItems(const ItemList & Items,ItemList & NativeItems)30 Linker::LinkInItems(const ItemList& Items, ItemList& NativeItems) {
31   // Clear the NativeItems just in case
32   NativeItems.clear();
33 
34   // For each linkage item ...
35   for (ItemList::const_iterator I = Items.begin(), E = Items.end();
36        I != E; ++I) {
37     if (I->second) {
38       // Link in the library suggested.
39       bool is_native = false;
40       if (LinkInLibrary(I->first, is_native))
41         return true;
42       if (is_native)
43         NativeItems.push_back(*I);
44     } else {
45       // Link in the file suggested
46       bool is_native = false;
47       if (LinkInFile(sys::Path(I->first), is_native))
48         return true;
49       if (is_native)
50         NativeItems.push_back(*I);
51     }
52   }
53 
54   // At this point we have processed all the link items provided to us. Since
55   // we have an aggregated module at this point, the dependent libraries in
56   // that module should also be aggregated with duplicates eliminated. This is
57   // now the time to process the dependent libraries to resolve any remaining
58   // symbols.
59   bool is_native;
60   for (Module::lib_iterator I = Composite->lib_begin(),
61          E = Composite->lib_end(); I != E; ++I) {
62     if(LinkInLibrary(*I, is_native))
63       return true;
64     if (is_native)
65       NativeItems.push_back(std::make_pair(*I, true));
66   }
67 
68   return false;
69 }
70 
71 
72 /// LinkInLibrary - links one library into the HeadModule.
73 ///
LinkInLibrary(StringRef Lib,bool & is_native)74 bool Linker::LinkInLibrary(StringRef Lib, bool& is_native) {
75   is_native = false;
76   // Determine where this library lives.
77   sys::Path Pathname = FindLib(Lib);
78   if (Pathname.isEmpty())
79     return error("Cannot find library '" + Lib.str() + "'");
80 
81   // If its an archive, try to link it in
82   std::string Magic;
83   Pathname.getMagicNumber(Magic, 64);
84   switch (sys::IdentifyFileType(Magic.c_str(), 64)) {
85     default: llvm_unreachable("Bad file type identification");
86     case sys::Unknown_FileType:
87       return warning("Supposed library '" + Lib.str() + "' isn't a library.");
88 
89     case sys::Bitcode_FileType:
90       // LLVM ".so" file.
91       if (LinkInFile(Pathname, is_native))
92         return true;
93       break;
94 
95     case sys::Archive_FileType:
96       if (LinkInArchive(Pathname, is_native))
97         return error("Cannot link archive '" + Pathname.str() + "'");
98       break;
99 
100     case sys::ELF_Relocatable_FileType:
101     case sys::ELF_SharedObject_FileType:
102     case sys::Mach_O_Object_FileType:
103     case sys::Mach_O_FixedVirtualMemorySharedLib_FileType:
104     case sys::Mach_O_DynamicallyLinkedSharedLib_FileType:
105     case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType:
106     case sys::COFF_FileType:
107       is_native = true;
108       break;
109   }
110   return false;
111 }
112 
113 /// LinkLibraries - takes the specified library files and links them into the
114 /// main bitcode object file.
115 ///
116 /// Inputs:
117 ///  Libraries  - The list of libraries to link into the module.
118 ///
119 /// Return value:
120 ///  FALSE - No error.
121 ///  TRUE  - Error.
122 ///
LinkInLibraries(const std::vector<std::string> & Libraries)123 bool Linker::LinkInLibraries(const std::vector<std::string> &Libraries) {
124 
125   // Process the set of libraries we've been provided.
126   bool is_native = false;
127   for (unsigned i = 0; i < Libraries.size(); ++i)
128     if (LinkInLibrary(Libraries[i], is_native))
129       return true;
130 
131   // At this point we have processed all the libraries provided to us. Since
132   // we have an aggregated module at this point, the dependent libraries in
133   // that module should also be aggregated with duplicates eliminated. This is
134   // now the time to process the dependent libraries to resolve any remaining
135   // symbols.
136   const Module::LibraryListType& DepLibs = Composite->getLibraries();
137   for (Module::LibraryListType::const_iterator I = DepLibs.begin(),
138          E = DepLibs.end(); I != E; ++I)
139     if (LinkInLibrary(*I, is_native))
140       return true;
141 
142   return false;
143 }
144 
145 /// LinkInFile - opens a bitcode file and links in all objects which
146 /// provide symbols that are currently undefined.
147 ///
148 /// Inputs:
149 ///  File - The pathname of the bitcode file.
150 ///
151 /// Outputs:
152 ///  ErrorMessage - A C++ string detailing what error occurred, if any.
153 ///
154 /// Return Value:
155 ///  TRUE  - An error occurred.
156 ///  FALSE - No errors.
157 ///
LinkInFile(const sys::Path & File,bool & is_native)158 bool Linker::LinkInFile(const sys::Path &File, bool &is_native) {
159   is_native = false;
160 
161   // Check for a file of name "-", which means "read standard input"
162   if (File.str() == "-") {
163     std::auto_ptr<Module> M;
164     OwningPtr<MemoryBuffer> Buffer;
165     error_code ec;
166     if (!(ec = MemoryBuffer::getSTDIN(Buffer))) {
167       if (!Buffer->getBufferSize()) {
168         Error = "standard input is empty";
169       } else {
170         M.reset(ParseBitcodeFile(Buffer.get(), Context, &Error));
171         if (M.get())
172           if (!LinkInModule(M.get(), &Error))
173             return false;
174       }
175     }
176     return error("Cannot link stdin: " + ec.message());
177   }
178 
179   // Determine what variety of file it is.
180   std::string Magic;
181   if (!File.getMagicNumber(Magic, 64))
182     return error("Cannot find linker input '" + File.str() + "'");
183 
184   switch (sys::IdentifyFileType(Magic.c_str(), 64)) {
185     default: llvm_unreachable("Bad file type identification");
186     case sys::Unknown_FileType:
187       return warning("Ignoring file '" + File.str() +
188                    "' because does not contain bitcode.");
189 
190     case sys::Archive_FileType:
191       // A user may specify an ar archive without -l, perhaps because it
192       // is not installed as a library. Detect that and link the archive.
193       if (LinkInArchive(File, is_native))
194         return true;
195       break;
196 
197     case sys::Bitcode_FileType: {
198       verbose("Linking bitcode file '" + File.str() + "'");
199       std::auto_ptr<Module> M(LoadObject(File));
200       if (M.get() == 0)
201         return error("Cannot load file '" + File.str() + "': " + Error);
202       if (LinkInModule(M.get(), &Error))
203         return error("Cannot link file '" + File.str() + "': " + Error);
204 
205       verbose("Linked in file '" + File.str() + "'");
206       break;
207     }
208 
209     case sys::ELF_Relocatable_FileType:
210     case sys::ELF_SharedObject_FileType:
211     case sys::Mach_O_Object_FileType:
212     case sys::Mach_O_FixedVirtualMemorySharedLib_FileType:
213     case sys::Mach_O_DynamicallyLinkedSharedLib_FileType:
214     case sys::Mach_O_DynamicallyLinkedSharedLibStub_FileType:
215     case sys::COFF_FileType:
216       is_native = true;
217       break;
218   }
219   return false;
220 }
221 
222 /// LinkFiles - takes a module and a list of files and links them all together.
223 /// It locates the file either in the current directory, as its absolute
224 /// or relative pathname, or as a file somewhere in LLVM_LIB_SEARCH_PATH.
225 ///
226 /// Inputs:
227 ///  Files      - A vector of sys::Path indicating the LLVM bitcode filenames
228 ///               to be linked.  The names can refer to a mixture of pure LLVM
229 ///               bitcode files and archive (ar) formatted files.
230 ///
231 /// Return value:
232 ///  FALSE - No errors.
233 ///  TRUE  - Some error occurred.
234 ///
LinkInFiles(const std::vector<sys::Path> & Files)235 bool Linker::LinkInFiles(const std::vector<sys::Path> &Files) {
236   bool is_native;
237   for (unsigned i = 0; i < Files.size(); ++i)
238     if (LinkInFile(Files[i], is_native))
239       return true;
240   return false;
241 }
242