1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use std
::ffi
::OsString
;
12 use std
::fs
::{self, File}
;
13 use std
::io
::{self, BufWriter}
;
14 use std
::io
::prelude
::*;
15 use std
::path
::{Path, PathBuf}
;
16 use std
::process
::Command
;
19 use middle
::cstore
::CrateStore
;
20 use middle
::dependency_format
::Linkage
;
22 use session
::config
::CrateTypeDylib
;
27 /// Linker abstraction used by back::link to build up the command to invoke a
30 /// This trait is the total list of requirements needed by `back::link` and
31 /// represents the meaning of each option being passed down. This trait is then
32 /// used to dispatch on whether a GNU-like linker (generally `ld.exe`) or an
33 /// MSVC linker (e.g. `link.exe`) is being used.
35 fn link_dylib(&mut self, lib
: &str);
36 fn link_rust_dylib(&mut self, lib
: &str, path
: &Path
);
37 fn link_framework(&mut self, framework
: &str);
38 fn link_staticlib(&mut self, lib
: &str);
39 fn link_rlib(&mut self, lib
: &Path
);
40 fn link_whole_rlib(&mut self, lib
: &Path
);
41 fn link_whole_staticlib(&mut self, lib
: &str, search_path
: &[PathBuf
]);
42 fn include_path(&mut self, path
: &Path
);
43 fn framework_path(&mut self, path
: &Path
);
44 fn output_filename(&mut self, path
: &Path
);
45 fn add_object(&mut self, path
: &Path
);
46 fn gc_sections(&mut self, is_dylib
: bool
);
47 fn position_independent_executable(&mut self);
48 fn optimize(&mut self);
49 fn debuginfo(&mut self);
50 fn no_default_libraries(&mut self);
51 fn build_dylib(&mut self, out_filename
: &Path
);
52 fn args(&mut self, args
: &[String
]);
53 fn hint_static(&mut self);
54 fn hint_dynamic(&mut self);
55 fn whole_archives(&mut self);
56 fn no_whole_archives(&mut self);
57 fn export_symbols(&mut self, sess
: &Session
, trans
: &CrateTranslation
,
61 pub struct GnuLinker
<'a
> {
62 pub cmd
: &'a
mut Command
,
63 pub sess
: &'a Session
,
66 impl<'a
> GnuLinker
<'a
> {
67 fn takes_hints(&self) -> bool
{
68 !self.sess
.target
.target
.options
.is_like_osx
72 impl<'a
> Linker
for GnuLinker
<'a
> {
73 fn link_dylib(&mut self, lib
: &str) { self.cmd.arg("-l").arg(lib); }
74 fn link_staticlib(&mut self, lib
: &str) { self.cmd.arg("-l").arg(lib); }
75 fn link_rlib(&mut self, lib
: &Path
) { self.cmd.arg(lib); }
76 fn include_path(&mut self, path
: &Path
) { self.cmd.arg("-L").arg(path); }
77 fn framework_path(&mut self, path
: &Path
) { self.cmd.arg("-F").arg(path); }
78 fn output_filename(&mut self, path
: &Path
) { self.cmd.arg("-o").arg(path); }
79 fn add_object(&mut self, path
: &Path
) { self.cmd.arg(path); }
80 fn position_independent_executable(&mut self) { self.cmd.arg("-pie"); }
81 fn args(&mut self, args
: &[String
]) { self.cmd.args(args); }
83 fn link_rust_dylib(&mut self, lib
: &str, _path
: &Path
) {
84 self.cmd
.arg("-l").arg(lib
);
87 fn link_framework(&mut self, framework
: &str) {
88 self.cmd
.arg("-framework").arg(framework
);
91 fn link_whole_staticlib(&mut self, lib
: &str, search_path
: &[PathBuf
]) {
92 let target
= &self.sess
.target
.target
;
93 if !target
.options
.is_like_osx
{
94 self.cmd
.arg("-Wl,--whole-archive")
96 .arg("-Wl,--no-whole-archive");
98 // -force_load is the OSX equivalent of --whole-archive, but it
99 // involves passing the full path to the library to link.
100 let mut v
= OsString
::from("-Wl,-force_load,");
101 v
.push(&archive
::find_library(lib
, search_path
, &self.sess
));
106 fn link_whole_rlib(&mut self, lib
: &Path
) {
107 if self.sess
.target
.target
.options
.is_like_osx
{
108 let mut v
= OsString
::from("-Wl,-force_load,");
112 self.cmd
.arg("-Wl,--whole-archive").arg(lib
)
113 .arg("-Wl,--no-whole-archive");
117 fn gc_sections(&mut self, is_dylib
: bool
) {
118 // The dead_strip option to the linker specifies that functions and data
119 // unreachable by the entry point will be removed. This is quite useful
120 // with Rust's compilation model of compiling libraries at a time into
121 // one object file. For example, this brings hello world from 1.7MB to
124 // Note that this is done for both executables and dynamic libraries. We
125 // won't get much benefit from dylibs because LLVM will have already
126 // stripped away as much as it could. This has not been seen to impact
127 // link times negatively.
129 // -dead_strip can't be part of the pre_link_args because it's also used
130 // for partial linking when using multiple codegen units (-r). So we
132 if self.sess
.target
.target
.options
.is_like_osx
{
133 self.cmd
.arg("-Wl,-dead_strip");
134 } else if self.sess
.target
.target
.options
.is_like_solaris
{
135 self.cmd
.arg("-Wl,-z");
136 self.cmd
.arg("-Wl,ignore");
138 // If we're building a dylib, we don't use --gc-sections because LLVM
139 // has already done the best it can do, and we also don't want to
140 // eliminate the metadata. If we're building an executable, however,
141 // --gc-sections drops the size of hello world from 1.8MB to 597K, a 67%
143 } else if !is_dylib
{
144 self.cmd
.arg("-Wl,--gc-sections");
148 fn optimize(&mut self) {
149 if !self.sess
.target
.target
.options
.linker_is_gnu { return }
151 // GNU-style linkers support optimization with -O. GNU ld doesn't
152 // need a numeric argument, but other linkers do.
153 if self.sess
.opts
.optimize
== config
::OptLevel
::Default
||
154 self.sess
.opts
.optimize
== config
::OptLevel
::Aggressive
{
155 self.cmd
.arg("-Wl,-O1");
159 fn debuginfo(&mut self) {
160 // Don't do anything special here for GNU-style linkers.
163 fn no_default_libraries(&mut self) {
164 self.cmd
.arg("-nodefaultlibs");
167 fn build_dylib(&mut self, out_filename
: &Path
) {
168 // On mac we need to tell the linker to let this library be rpathed
169 if self.sess
.target
.target
.options
.is_like_osx
{
170 self.cmd
.args(&["-dynamiclib", "-Wl,-dylib"]);
172 if self.sess
.opts
.cg
.rpath
{
173 let mut v
= OsString
::from("-Wl,-install_name,@rpath/");
174 v
.push(out_filename
.file_name().unwrap());
178 self.cmd
.arg("-shared");
182 fn whole_archives(&mut self) {
183 if !self.takes_hints() { return }
184 self.cmd
.arg("-Wl,--whole-archive");
187 fn no_whole_archives(&mut self) {
188 if !self.takes_hints() { return }
189 self.cmd
.arg("-Wl,--no-whole-archive");
192 fn hint_static(&mut self) {
193 if !self.takes_hints() { return }
194 self.cmd
.arg("-Wl,-Bstatic");
197 fn hint_dynamic(&mut self) {
198 if !self.takes_hints() { return }
199 self.cmd
.arg("-Wl,-Bdynamic");
202 fn export_symbols(&mut self, _
: &Session
, _
: &CrateTranslation
, _
: &Path
) {
203 // noop, visibility in object files takes care of this
207 pub struct MsvcLinker
<'a
> {
208 pub cmd
: &'a
mut Command
,
209 pub sess
: &'a Session
,
212 impl<'a
> Linker
for MsvcLinker
<'a
> {
213 fn link_rlib(&mut self, lib
: &Path
) { self.cmd.arg(lib); }
214 fn add_object(&mut self, path
: &Path
) { self.cmd.arg(path); }
215 fn args(&mut self, args
: &[String
]) { self.cmd.args(args); }
217 fn build_dylib(&mut self, out_filename
: &Path
) {
218 self.cmd
.arg("/DLL");
219 let mut arg
: OsString
= "/IMPLIB:".into();
220 arg
.push(out_filename
.with_extension("dll.lib"));
224 fn gc_sections(&mut self, _is_dylib
: bool
) { self.cmd.arg("/OPT:REF,ICF"); }
226 fn link_dylib(&mut self, lib
: &str) {
227 self.cmd
.arg(&format
!("{}.lib", lib
));
230 fn link_rust_dylib(&mut self, lib
: &str, path
: &Path
) {
231 // When producing a dll, the MSVC linker may not actually emit a
232 // `foo.lib` file if the dll doesn't actually export any symbols, so we
233 // check to see if the file is there and just omit linking to it if it's
235 let name
= format
!("{}.dll.lib", lib
);
236 if fs
::metadata(&path
.join(&name
)).is_ok() {
241 fn link_staticlib(&mut self, lib
: &str) {
242 self.cmd
.arg(&format
!("{}.lib", lib
));
245 fn position_independent_executable(&mut self) {
249 fn no_default_libraries(&mut self) {
250 // Currently we don't pass the /NODEFAULTLIB flag to the linker on MSVC
251 // as there's been trouble in the past of linking the C++ standard
252 // library required by LLVM. This likely needs to happen one day, but
253 // in general Windows is also a more controlled environment than
254 // Unix, so it's not necessarily as critical that this be implemented.
256 // Note that there are also some licensing worries about statically
257 // linking some libraries which require a specific agreement, so it may
258 // not ever be possible for us to pass this flag.
261 fn include_path(&mut self, path
: &Path
) {
262 let mut arg
= OsString
::from("/LIBPATH:");
267 fn output_filename(&mut self, path
: &Path
) {
268 let mut arg
= OsString
::from("/OUT:");
273 fn framework_path(&mut self, _path
: &Path
) {
274 bug
!("frameworks are not supported on windows")
276 fn link_framework(&mut self, _framework
: &str) {
277 bug
!("frameworks are not supported on windows")
280 fn link_whole_staticlib(&mut self, lib
: &str, _search_path
: &[PathBuf
]) {
282 self.link_staticlib(lib
);
284 fn link_whole_rlib(&mut self, path
: &Path
) {
286 self.link_rlib(path
);
288 fn optimize(&mut self) {
289 // Needs more investigation of `/OPT` arguments
292 fn debuginfo(&mut self) {
293 // This will cause the Microsoft linker to generate a PDB file
294 // from the CodeView line tables in the object files.
295 self.cmd
.arg("/DEBUG");
298 fn whole_archives(&mut self) {
299 // hints not supported?
301 fn no_whole_archives(&mut self) {
302 // hints not supported?
305 // On windows static libraries are of the form `foo.lib` and dynamic
306 // libraries are not linked against directly, but rather through their
307 // import libraries also called `foo.lib`. As a result there's no
308 // possibility for a native library to appear both dynamically and
309 // statically in the same folder so we don't have to worry about hints like
310 // we do on Unix platforms.
311 fn hint_static(&mut self) {}
312 fn hint_dynamic(&mut self) {}
314 // Currently the compiler doesn't use `dllexport` (an LLVM attribute) to
315 // export symbols from a dynamic library. When building a dynamic library,
316 // however, we're going to want some symbols exported, so this function
317 // generates a DEF file which lists all the symbols.
319 // The linker will read this `*.def` file and export all the symbols from
320 // the dynamic library. Note that this is not as simple as just exporting
321 // all the symbols in the current crate (as specified by `trans.reachable`)
322 // but rather we also need to possibly export the symbols of upstream
323 // crates. Upstream rlibs may be linked statically to this dynamic library,
324 // in which case they may continue to transitively be used and hence need
325 // their symbols exported.
326 fn export_symbols(&mut self, sess
: &Session
, trans
: &CrateTranslation
,
328 let path
= tmpdir
.join("lib.def");
329 let res
= (|| -> io
::Result
<()> {
330 let mut f
= BufWriter
::new(File
::create(&path
)?
);
332 // Start off with the standard module name header and then go
333 // straight to exports.
334 writeln
!(f
, "LIBRARY")?
;
335 writeln
!(f
, "EXPORTS")?
;
337 // Write out all our local symbols
338 for sym
in trans
.reachable
.iter() {
339 writeln
!(f
, " {}", sym
)?
;
342 // Take a look at how all upstream crates are linked into this
343 // dynamic library. For all statically linked libraries we take all
344 // their reachable symbols and emit them as well.
345 let cstore
= &sess
.cstore
;
346 let formats
= sess
.dependency_formats
.borrow();
347 let symbols
= formats
[&CrateTypeDylib
].iter();
348 let symbols
= symbols
.enumerate().filter_map(|(i
, f
)| {
349 if *f
== Linkage
::Static
{
350 Some((i
+ 1) as ast
::CrateNum
)
355 cstore
.reachable_ids(cnum
)
357 cstore
.item_symbol(did
)
359 for symbol
in symbols
{
360 writeln
!(f
, " {}", symbol
)?
;
365 if let Err(e
) = res
{
366 sess
.fatal(&format
!("failed to write lib.def file: {}", e
));
368 let mut arg
= OsString
::from("/DEF:");