1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
//===- lib/Linker/Linker.cpp - Basic Linker functionality ----------------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Reid Spencer and is distributed under the
// University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains basic Linker functionality that all usages will need.
//
//===----------------------------------------------------------------------===//
#include "llvm/Linker.h"
#include "llvm/Module.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Config/config.h"
#include <iostream>
using namespace llvm;
Linker::Linker(const std::string& progname, unsigned flags)
: Composite(0)
, LibPaths()
, Flags(flags)
, Error()
, ProgramName(progname)
{
Composite = new Module(progname);
}
Linker::Linker(const std::string& progname, Module* aModule, unsigned flags)
: Composite(aModule)
, LibPaths()
, Flags(flags)
, Error()
, ProgramName(progname)
{
}
Linker::~Linker() {
delete Composite;
}
bool
Linker::error(const std::string& message) {
Error = message;
if (!(Flags&QuietErrors)) {
std::cerr << ProgramName << ": error: " << message << "\n";
}
return true;
}
bool
Linker::warning(const std::string& message) {
Error = message;
if (!(Flags&QuietErrors)) {
std::cerr << ProgramName << ": warning: " << message << "\n";
}
return false;
}
void
Linker::verbose(const std::string& message) {
if (Flags&Verbose) {
std::cerr << " " << message << "\n";
}
}
void
Linker::addPath(const sys::Path& path) {
assert(path.isDirectory() && "Can only insert directories into the path");
LibPaths.push_back(path);
}
void
Linker::addPaths(const std::vector<std::string>& paths) {
for (unsigned i = 0; i != paths.size(); ++i) {
sys::Path aPath;
aPath.setDirectory(paths[i]);
LibPaths.push_back(aPath);
}
}
void
Linker::addSystemPaths() {
sys::Path::GetBytecodeLibraryPaths(LibPaths);
LibPaths.insert(LibPaths.begin(),sys::Path("./"));
}
Module*
Linker::releaseModule() {
Module* result = Composite;
LibPaths.clear();
Error.clear();
Composite = 0;
Flags = 0;
return result;
}
// LoadObject - Read in and parse the bytecode file named by FN and return the
// module it contains (wrapped in an auto_ptr), or auto_ptr<Module>() and set
// Error if an error occurs.
std::auto_ptr<Module>
Linker::LoadObject(const sys::Path &FN) {
std::string ParseErrorMessage;
Module *Result = ParseBytecodeFile(FN.toString(), &ParseErrorMessage);
if (Result)
return std::auto_ptr<Module>(Result);
Error = "Bytecode file '" + FN.toString() + "' could not be loaded";
if (ParseErrorMessage.size())
Error += ": " + ParseErrorMessage;
return std::auto_ptr<Module>();
}
// IsLibrary - Determine if "Name" is a library in "Directory". Return
// a non-empty sys::Path if its found, an empty one otherwise.
static inline sys::Path IsLibrary(const std::string& Name,
const sys::Path& Directory) {
assert(Directory.isDirectory() && "Need to specify a directory");
sys::Path FullPath(Directory);
FullPath.appendFile("lib" + Name);
FullPath.appendSuffix("a");
if (FullPath.isArchive())
return FullPath;
FullPath.elideSuffix();
FullPath.appendSuffix("bca");
if (FullPath.isArchive())
return FullPath;
FullPath.elideSuffix();
FullPath.appendSuffix(&(LTDL_SHLIB_EXT[1]));
if (FullPath.isDynamicLibrary()) // Native shared library?
return FullPath;
if (FullPath.isBytecodeFile()) // .so file containing bytecode?
return FullPath;
FullPath.clear();
return FullPath;
}
/// FindLib - Try to convert Filename into the name of a file that we can open,
/// if it does not already name a file we can open, by first trying to open
/// Filename, then libFilename.[suffix] for each of a set of several common
/// library suffixes, in each of the directories in LibPaths. Returns an empty
/// Path if no matching file can be found.
///
sys::Path
Linker::FindLib(const std::string &Filename)
{
// Determine if the pathname can be found as it stands.
sys::Path FilePath(Filename);
if (FilePath.readable() &&
(FilePath.isArchive() || FilePath.isDynamicLibrary()))
return FilePath;
// Iterate over the directories in Paths to see if we can find the library
// there.
for (unsigned Index = 0; Index != LibPaths.size(); ++Index) {
sys::Path Directory(LibPaths[Index]);
sys::Path FullPath = IsLibrary(Filename,Directory);
if (!FullPath.isEmpty())
return FullPath;
}
return sys::Path();
}
|
