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"
22using 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.
29bool
30Linker::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///
74bool 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///
123bool 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///
158bool 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///
235bool 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