1 // Copyright 2012-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 //! Finds crate binaries and loads their metadata
13 //! Might I be the first to welcome you to a world of platform differences,
14 //! version requirements, dependency graphs, conflicting desires, and fun! This
15 //! is the major guts (along with metadata::creader) of the compiler for loading
16 //! crates and resolving dependencies. Let's take a tour!
20 //! Each invocation of the compiler is immediately concerned with one primary
21 //! problem, to connect a set of crates to resolved crates on the filesystem.
22 //! Concretely speaking, the compiler follows roughly these steps to get here:
24 //! 1. Discover a set of `extern crate` statements.
25 //! 2. Transform these directives into crate names. If the directive does not
26 //! have an explicit name, then the identifier is the name.
27 //! 3. For each of these crate names, find a corresponding crate on the
30 //! Sounds easy, right? Let's walk into some of the nuances.
32 //! ## Transitive Dependencies
34 //! Let's say we've got three crates: A, B, and C. A depends on B, and B depends
35 //! on C. When we're compiling A, we primarily need to find and locate B, but we
36 //! also end up needing to find and locate C as well.
38 //! The reason for this is that any of B's types could be composed of C's types,
39 //! any function in B could return a type from C, etc. To be able to guarantee
40 //! that we can always typecheck/translate any function, we have to have
41 //! complete knowledge of the whole ecosystem, not just our immediate
44 //! So now as part of the "find a corresponding crate on the filesystem" step
45 //! above, this involves also finding all crates for *all upstream
46 //! dependencies*. This includes all dependencies transitively.
48 //! ## Rlibs and Dylibs
50 //! The compiler has two forms of intermediate dependencies. These are dubbed
51 //! rlibs and dylibs for the static and dynamic variants, respectively. An rlib
52 //! is a rustc-defined file format (currently just an ar archive) while a dylib
53 //! is a platform-defined dynamic library. Each library has a metadata somewhere
56 //! When translating a crate name to a crate on the filesystem, we all of a
57 //! sudden need to take into account both rlibs and dylibs! Linkage later on may
58 //! use either one of these files, as each has their pros/cons. The job of crate
59 //! loading is to discover what's possible by finding all candidates.
61 //! Most parts of this loading systems keep the dylib/rlib as just separate
66 //! We can't exactly scan your whole hard drive when looking for dependencies,
67 //! so we need to places to look. Currently the compiler will implicitly add the
68 //! target lib search path ($prefix/lib/rustlib/$target/lib) to any compilation,
69 //! and otherwise all -L flags are added to the search paths.
71 //! ## What criterion to select on?
73 //! This a pretty tricky area of loading crates. Given a file, how do we know
74 //! whether it's the right crate? Currently, the rules look along these lines:
76 //! 1. Does the filename match an rlib/dylib pattern? That is to say, does the
77 //! filename have the right prefix/suffix?
78 //! 2. Does the filename have the right prefix for the crate name being queried?
79 //! This is filtering for files like `libfoo*.rlib` and such.
80 //! 3. Is the file an actual rust library? This is done by loading the metadata
81 //! from the library and making sure it's actually there.
82 //! 4. Does the name in the metadata agree with the name of the library?
83 //! 5. Does the target in the metadata agree with the current target?
84 //! 6. Does the SVH match? (more on this later)
86 //! If the file answers `yes` to all these questions, then the file is
87 //! considered as being *candidate* for being accepted. It is illegal to have
88 //! more than two candidates as the compiler has no method by which to resolve
89 //! this conflict. Additionally, rlib/dylib candidates are considered
92 //! After all this has happened, we have 1 or two files as candidates. These
93 //! represent the rlib/dylib file found for a library, and they're returned as
96 //! ### What about versions?
98 //! A lot of effort has been put forth to remove versioning from the compiler.
99 //! There have been forays in the past to have versioning baked in, but it was
100 //! largely always deemed insufficient to the point that it was recognized that
101 //! it's probably something the compiler shouldn't do anyway due to its
102 //! complicated nature and the state of the half-baked solutions.
104 //! With a departure from versioning, the primary criterion for loading crates
105 //! is just the name of a crate. If we stopped here, it would imply that you
106 //! could never link two crates of the same name from different sources
107 //! together, which is clearly a bad state to be in.
109 //! To resolve this problem, we come to the next section!
113 //! A number of flags have been added to the compiler to solve the "version
114 //! problem" in the previous section, as well as generally enabling more
115 //! powerful usage of the crate loading system of the compiler. The goal of
116 //! these flags and options are to enable third-party tools to drive the
117 //! compiler with prior knowledge about how the world should look.
119 //! ## The `--extern` flag
121 //! The compiler accepts a flag of this form a number of times:
124 //! --extern crate-name=path/to/the/crate.rlib
127 //! This flag is basically the following letter to the compiler:
131 //! > When you are attempting to load the immediate dependency `crate-name`, I
132 //! > would like you to assume that the library is located at
133 //! > `path/to/the/crate.rlib`, and look nowhere else. Also, please do not
134 //! > assume that the path I specified has the name `crate-name`.
136 //! This flag basically overrides most matching logic except for validating that
137 //! the file is indeed a rust library. The same `crate-name` can be specified
138 //! twice to specify the rlib/dylib pair.
140 //! ## Enabling "multiple versions"
142 //! This basically boils down to the ability to specify arbitrary packages to
143 //! the compiler. For example, if crate A wanted to use Bv1 and Bv2, then it
144 //! would look something like:
153 //! and the compiler would be invoked as:
156 //! rustc a.rs --extern b1=path/to/libb1.rlib --extern b2=path/to/libb2.rlib
159 //! In this scenario there are two crates named `b` and the compiler must be
160 //! manually driven to be informed where each crate is.
162 //! ## Frobbing symbols
164 //! One of the immediate problems with linking the same library together twice
165 //! in the same problem is dealing with duplicate symbols. The primary way to
166 //! deal with this in rustc is to add hashes to the end of each symbol.
168 //! In order to force hashes to change between versions of a library, if
169 //! desired, the compiler exposes an option `-C metadata=foo`, which is used to
170 //! initially seed each symbol hash. The string `foo` is prepended to each
171 //! string-to-hash to ensure that symbols change over time.
173 //! ## Loading transitive dependencies
175 //! Dealing with same-named-but-distinct crates is not just a local problem, but
176 //! one that also needs to be dealt with for transitive dependencies. Note that
177 //! in the letter above `--extern` flags only apply to the *local* set of
178 //! dependencies, not the upstream transitive dependencies. Consider this
179 //! dependency graph:
191 //! In this scenario, when we compile `D`, we need to be able to distinctly
192 //! resolve `A.1` and `A.2`, but an `--extern` flag cannot apply to these
193 //! transitive dependencies.
195 //! Note that the key idea here is that `B` and `C` are both *already compiled*.
196 //! That is, they have already resolved their dependencies. Due to unrelated
197 //! technical reasons, when a library is compiled, it is only compatible with
198 //! the *exact same* version of the upstream libraries it was compiled against.
199 //! We use the "Strict Version Hash" to identify the exact copy of an upstream
202 //! With this knowledge, we know that `B` and `C` will depend on `A` with
203 //! different SVH values, so we crawl the normal `-L` paths looking for
204 //! `liba*.rlib` and filter based on the contained SVH.
206 //! In the end, this ends up not needing `--extern` to specify upstream
207 //! transitive dependencies.
211 //! That's the general overview of loading crates in the compiler, but it's by
212 //! no means all of the necessary details. Take a look at the rest of
213 //! metadata::loader or metadata::creader for all the juicy details!
215 use cstore
::{MetadataBlob, MetadataVec, MetadataArchive}
;
216 use common
::{metadata_encoding_version, rustc_version}
;
219 use rustc
::hir
::svh
::Svh
;
220 use rustc
::session
::Session
;
221 use rustc
::session
::filesearch
::{FileSearch, FileMatches, FileDoesntMatch}
;
222 use rustc
::session
::search_paths
::PathKind
;
223 use rustc
::util
::common
;
225 use rustc_llvm
as llvm
;
226 use rustc_llvm
::{False, ObjectFile, mk_section_iter}
;
227 use rustc_llvm
::archive_ro
::ArchiveRO
;
228 use errors
::DiagnosticBuilder
;
229 use syntax_pos
::Span
;
230 use rustc_back
::target
::Target
;
233 use std
::collections
::HashMap
;
237 use std
::path
::{Path, PathBuf}
;
240 use std
::time
::Instant
;
244 pub struct CrateMismatch
{
249 pub struct Context
<'a
> {
250 pub sess
: &'a Session
,
253 pub crate_name
: &'a
str,
254 pub hash
: Option
<&'a Svh
>,
255 // points to either self.sess.target.target or self.sess.host, must match triple
256 pub target
: &'a Target
,
258 pub filesearch
: FileSearch
<'a
>,
259 pub root
: &'a Option
<CratePaths
>,
260 pub rejected_via_hash
: Vec
<CrateMismatch
>,
261 pub rejected_via_triple
: Vec
<CrateMismatch
>,
262 pub rejected_via_kind
: Vec
<CrateMismatch
>,
263 pub rejected_via_version
: Vec
<CrateMismatch
>,
264 pub should_match_name
: bool
,
268 pub dylib
: Option
<(PathBuf
, PathKind
)>,
269 pub rlib
: Option
<(PathBuf
, PathKind
)>,
270 pub metadata
: MetadataBlob
,
273 pub struct ArchiveMetadata
{
275 // points into self._archive
279 pub struct CratePaths
{
281 pub dylib
: Option
<PathBuf
>,
282 pub rlib
: Option
<PathBuf
>
285 pub const METADATA_FILENAME
: &'
static str = "rust.metadata.bin";
287 #[derive(Copy, Clone, PartialEq)]
293 impl fmt
::Display
for CrateFlavor
{
294 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
295 f
.write_str(match *self {
296 CrateFlavor
::Rlib
=> "rlib",
297 CrateFlavor
::Dylib
=> "dylib"
303 fn paths(&self) -> Vec
<PathBuf
> {
304 match (&self.dylib
, &self.rlib
) {
305 (&None
, &None
) => vec
!(),
306 (&Some(ref p
), &None
) |
307 (&None
, &Some(ref p
)) => vec
!(p
.clone()),
308 (&Some(ref p1
), &Some(ref p2
)) => vec
!(p1
.clone(), p2
.clone()),
313 impl<'a
> Context
<'a
> {
314 pub fn maybe_load_library_crate(&mut self) -> Option
<Library
> {
315 self.find_library_crate()
318 pub fn load_library_crate(&mut self) -> Library
{
319 self.find_library_crate().unwrap_or_else(|| self.report_load_errs())
322 pub fn report_load_errs(&mut self) -> ! {
323 let add
= match self.root
{
324 &None
=> String
::new(),
325 &Some(ref r
) => format
!(" which `{}` depends on",
328 let mut err
= if !self.rejected_via_hash
.is_empty() {
329 struct_span_err
!(self.sess
, self.span
, E0460
,
330 "found possibly newer version of crate `{}`{}",
332 } else if !self.rejected_via_triple
.is_empty() {
333 struct_span_err
!(self.sess
, self.span
, E0461
,
334 "couldn't find crate `{}` with expected target triple {}{}",
335 self.ident
, self.triple
, add
)
336 } else if !self.rejected_via_kind
.is_empty() {
337 struct_span_err
!(self.sess
, self.span
, E0462
,
338 "found staticlib `{}` instead of rlib or dylib{}",
340 } else if !self.rejected_via_version
.is_empty() {
341 struct_span_err
!(self.sess
, self.span
, E0514
,
342 "found crate `{}` compiled by an incompatible version of rustc{}",
345 struct_span_err
!(self.sess
, self.span
, E0463
,
346 "can't find crate for `{}`{}",
350 if !self.rejected_via_triple
.is_empty() {
351 let mismatches
= self.rejected_via_triple
.iter();
352 for (i
, &CrateMismatch{ ref path, ref got }
) in mismatches
.enumerate() {
353 err
.note(&format
!("crate `{}`, path #{}, triple {}: {}",
354 self.ident
, i
+1, got
, path
.display()));
357 if !self.rejected_via_hash
.is_empty() {
358 err
.note("perhaps that crate needs to be recompiled?");
359 let mismatches
= self.rejected_via_hash
.iter();
360 for (i
, &CrateMismatch{ ref path, .. }
) in mismatches
.enumerate() {
361 err
.note(&format
!("crate `{}` path #{}: {}",
362 self.ident
, i
+1, path
.display()));
367 for (i
, path
) in r
.paths().iter().enumerate() {
368 err
.note(&format
!("crate `{}` path #{}: {}",
369 r
.ident
, i
+1, path
.display()));
374 if !self.rejected_via_kind
.is_empty() {
375 err
.help("please recompile that crate using --crate-type lib");
376 let mismatches
= self.rejected_via_kind
.iter();
377 for (i
, &CrateMismatch { ref path, .. }
) in mismatches
.enumerate() {
378 err
.note(&format
!("crate `{}` path #{}: {}",
379 self.ident
, i
+1, path
.display()));
382 if !self.rejected_via_version
.is_empty() {
383 err
.help(&format
!("please recompile that crate using this compiler ({})",
385 let mismatches
= self.rejected_via_version
.iter();
386 for (i
, &CrateMismatch { ref path, ref got }
) in mismatches
.enumerate() {
387 err
.note(&format
!("crate `{}` path #{}: {} compiled by {:?}",
388 self.ident
, i
+1, path
.display(), got
));
393 self.sess
.abort_if_errors();
397 fn find_library_crate(&mut self) -> Option
<Library
> {
398 // If an SVH is specified, then this is a transitive dependency that
399 // must be loaded via -L plus some filtering.
400 if self.hash
.is_none() {
401 self.should_match_name
= false;
402 if let Some(s
) = self.sess
.opts
.externs
.get(self.crate_name
) {
403 return self.find_commandline_library(s
.iter());
405 self.should_match_name
= true;
408 let dypair
= self.dylibname();
409 let staticpair
= self.staticlibname();
411 // want: crate_name.dir_part() + prefix + crate_name.file_part + "-"
412 let dylib_prefix
= format
!("{}{}", dypair
.0, self.crate_name
);
413 let rlib_prefix
= format
!("lib{}", self.crate_name
);
414 let staticlib_prefix
= format
!("{}{}", staticpair
.0, self.crate_name
);
416 let mut candidates
= HashMap
::new();
417 let mut staticlibs
= vec
!();
419 // First, find all possible candidate rlibs and dylibs purely based on
420 // the name of the files themselves. We're trying to match against an
421 // exact crate name and a possibly an exact hash.
423 // During this step, we can filter all found libraries based on the
424 // name and id found in the crate id (we ignore the path portion for
425 // filename matching), as well as the exact hash (if specified). If we
426 // end up having many candidates, we must look at the metadata to
427 // perform exact matches against hashes/crate ids. Note that opening up
428 // the metadata is where we do an exact match against the full contents
429 // of the crate id (path/name/id).
431 // The goal of this step is to look at as little metadata as possible.
432 self.filesearch
.search(|path
, kind
| {
433 let file
= match path
.file_name().and_then(|s
| s
.to_str()) {
434 None
=> return FileDoesntMatch
,
437 let (hash
, rlib
) = if file
.starts_with(&rlib_prefix
[..]) &&
438 file
.ends_with(".rlib") {
439 (&file
[(rlib_prefix
.len()) .. (file
.len() - ".rlib".len())],
441 } else if file
.starts_with(&dylib_prefix
) &&
442 file
.ends_with(&dypair
.1) {
443 (&file
[(dylib_prefix
.len()) .. (file
.len() - dypair
.1.len())],
446 if file
.starts_with(&staticlib_prefix
[..]) &&
447 file
.ends_with(&staticpair
.1) {
448 staticlibs
.push(CrateMismatch
{
449 path
: path
.to_path_buf(),
450 got
: "static".to_string()
453 return FileDoesntMatch
455 info
!("lib candidate: {}", path
.display());
457 let hash_str
= hash
.to_string();
458 let slot
= candidates
.entry(hash_str
)
459 .or_insert_with(|| (HashMap
::new(), HashMap
::new()));
460 let (ref mut rlibs
, ref mut dylibs
) = *slot
;
461 fs
::canonicalize(path
).map(|p
| {
463 rlibs
.insert(p
, kind
);
465 dylibs
.insert(p
, kind
);
468 }).unwrap_or(FileDoesntMatch
)
470 self.rejected_via_kind
.extend(staticlibs
);
472 // We have now collected all known libraries into a set of candidates
473 // keyed of the filename hash listed. For each filename, we also have a
474 // list of rlibs/dylibs that apply. Here, we map each of these lists
475 // (per hash), to a Library candidate for returning.
477 // A Library candidate is created if the metadata for the set of
478 // libraries corresponds to the crate id and hash criteria that this
479 // search is being performed for.
480 let mut libraries
= HashMap
::new();
481 for (_hash
, (rlibs
, dylibs
)) in candidates
{
483 let rlib
= self.extract_one(rlibs
, CrateFlavor
::Rlib
, &mut slot
);
484 let dylib
= self.extract_one(dylibs
, CrateFlavor
::Dylib
, &mut slot
);
485 if let Some((h
, m
)) = slot
{
486 libraries
.insert(h
, Library
{
494 // Having now translated all relevant found hashes into libraries, see
495 // what we've got and figure out if we found multiple candidates for
497 match libraries
.len() {
499 1 => Some(libraries
.into_iter().next().unwrap().1),
501 let mut err
= struct_span_err
!(self.sess
, self.span
, E0464
,
502 "multiple matching crates for `{}`",
504 err
.note("candidates:");
505 for (_
, lib
) in libraries
{
506 if let Some((ref p
, _
)) = lib
.dylib
{
507 err
.note(&format
!("path: {}", p
.display()));
509 if let Some((ref p
, _
)) = lib
.rlib
{
510 err
.note(&format
!("path: {}", p
.display()));
512 let data
= lib
.metadata
.as_slice();
513 let name
= decoder
::get_crate_name(data
);
514 note_crate_name(&mut err
, &name
);
522 // Attempts to extract *one* library from the set `m`. If the set has no
523 // elements, `None` is returned. If the set has more than one element, then
524 // the errors and notes are emitted about the set of libraries.
526 // With only one library in the set, this function will extract it, and then
527 // read the metadata from it if `*slot` is `None`. If the metadata couldn't
528 // be read, it is assumed that the file isn't a valid rust library (no
529 // errors are emitted).
530 fn extract_one(&mut self, m
: HashMap
<PathBuf
, PathKind
>, flavor
: CrateFlavor
,
531 slot
: &mut Option
<(Svh
, MetadataBlob
)>) -> Option
<(PathBuf
, PathKind
)> {
532 let mut ret
: Option
<(PathBuf
, PathKind
)> = None
;
536 // FIXME(#10786): for an optimization, we only read one of the
537 // libraries' metadata sections. In theory we should
538 // read both, but reading dylib metadata is quite
542 } else if m
.len() == 1 {
543 return Some(m
.into_iter().next().unwrap())
547 let mut err
: Option
<DiagnosticBuilder
> = None
;
548 for (lib
, kind
) in m
{
549 info
!("{} reading metadata from: {}", flavor
, lib
.display());
550 let (hash
, metadata
) = match get_metadata_section(self.target
, flavor
, &lib
) {
552 if let Some(h
) = self.crate_matches(blob
.as_slice(), &lib
) {
555 info
!("metadata mismatch");
560 info
!("no metadata found: {}", err
);
564 // If we see multiple hashes, emit an error about duplicate candidates.
565 if slot
.as_ref().map_or(false, |s
| s
.0 != hash
) {
566 let mut e
= struct_span_err
!(self.sess
, self.span
, E0465
,
567 "multiple {} candidates for `{}` found",
568 flavor
, self.crate_name
);
569 e
.span_note(self.span
,
570 &format
!(r
"candidate #1: {}",
571 ret
.as_ref().unwrap().0
573 if let Some(ref mut e
) = err
{
582 err
.as_mut().unwrap().span_note(self.span
,
583 &format
!(r
"candidate #{}: {}", error
,
587 *slot
= Some((hash
, metadata
));
588 ret
= Some((lib
, kind
));
599 fn crate_matches(&mut self, crate_data
: &[u8], libpath
: &Path
) -> Option
<Svh
> {
600 let crate_rustc_version
= decoder
::crate_rustc_version(crate_data
);
601 if crate_rustc_version
!= Some(rustc_version()) {
602 let message
= crate_rustc_version
.unwrap_or(format
!("an unknown compiler"));
603 info
!("Rejecting via version: expected {} got {}", rustc_version(), message
);
604 self.rejected_via_version
.push(CrateMismatch
{
605 path
: libpath
.to_path_buf(),
611 if self.should_match_name
{
612 match decoder
::maybe_get_crate_name(crate_data
) {
613 Some(ref name
) if self.crate_name
== *name
=> {}
614 _
=> { info!("Rejecting via crate name"); return None }
617 let hash
= match decoder
::maybe_get_crate_hash(crate_data
) {
618 None
=> { info!("Rejecting via lack of crate hash"); return None; }
622 let triple
= match decoder
::get_crate_triple(crate_data
) {
623 None
=> { debug!("triple not present"); return None }
626 if triple
!= self.triple
{
627 info
!("Rejecting via crate triple: expected {} got {}", self.triple
, triple
);
628 self.rejected_via_triple
.push(CrateMismatch
{
629 path
: libpath
.to_path_buf(),
630 got
: triple
.to_string()
635 if let Some(myhash
) = self.hash
{
637 info
!("Rejecting via hash: expected {} got {}", *myhash
, hash
);
638 self.rejected_via_hash
.push(CrateMismatch
{
639 path
: libpath
.to_path_buf(),
640 got
: myhash
.to_string()
650 // Returns the corresponding (prefix, suffix) that files need to have for
652 fn dylibname(&self) -> (String
, String
) {
653 let t
= &self.target
;
654 (t
.options
.dll_prefix
.clone(), t
.options
.dll_suffix
.clone())
657 // Returns the corresponding (prefix, suffix) that files need to have for
659 fn staticlibname(&self) -> (String
, String
) {
660 let t
= &self.target
;
661 (t
.options
.staticlib_prefix
.clone(), t
.options
.staticlib_suffix
.clone())
664 fn find_commandline_library
<'b
, LOCS
> (&mut self, locs
: LOCS
) -> Option
<Library
>
665 where LOCS
: Iterator
<Item
=&'b String
>
667 // First, filter out all libraries that look suspicious. We only accept
668 // files which actually exist that have the correct naming scheme for
670 let sess
= self.sess
;
671 let dylibname
= self.dylibname();
672 let mut rlibs
= HashMap
::new();
673 let mut dylibs
= HashMap
::new();
675 let locs
= locs
.map(|l
| PathBuf
::from(l
)).filter(|loc
| {
677 sess
.err(&format
!("extern location for {} does not exist: {}",
678 self.crate_name
, loc
.display()));
681 let file
= match loc
.file_name().and_then(|s
| s
.to_str()) {
684 sess
.err(&format
!("extern location for {} is not a file: {}",
685 self.crate_name
, loc
.display()));
689 if file
.starts_with("lib") && file
.ends_with(".rlib") {
692 let (ref prefix
, ref suffix
) = dylibname
;
693 if file
.starts_with(&prefix
[..]) &&
694 file
.ends_with(&suffix
[..]) {
698 sess
.struct_err(&format
!("extern location for {} is of an unknown type: {}",
699 self.crate_name
, loc
.display()))
700 .help(&format
!("file name should be lib*.rlib or {}*.{}",
701 dylibname
.0, dylibname
.1))
706 // Now that we have an iterator of good candidates, make sure
707 // there's at most one rlib and at most one dylib.
709 if loc
.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
710 rlibs
.insert(fs
::canonicalize(&loc
).unwrap(),
711 PathKind
::ExternFlag
);
713 dylibs
.insert(fs
::canonicalize(&loc
).unwrap(),
714 PathKind
::ExternFlag
);
719 // Extract the rlib/dylib pair.
721 let rlib
= self.extract_one(rlibs
, CrateFlavor
::Rlib
, &mut slot
);
722 let dylib
= self.extract_one(dylibs
, CrateFlavor
::Dylib
, &mut slot
);
724 if rlib
.is_none() && dylib
.is_none() { return None }
726 Some((_
, metadata
)) => Some(Library
{
736 pub fn note_crate_name(err
: &mut DiagnosticBuilder
, name
: &str) {
737 err
.note(&format
!("crate name: {}", name
));
740 impl ArchiveMetadata
{
741 fn new(ar
: ArchiveRO
) -> Option
<ArchiveMetadata
> {
743 let section
= ar
.iter().filter_map(|s
| s
.ok()).find(|sect
| {
744 sect
.name() == Some(METADATA_FILENAME
)
747 Some(s
) => s
.data() as *const [u8],
749 debug
!("didn't find '{}' in the archive", METADATA_FILENAME
);
755 Some(ArchiveMetadata
{
761 pub fn as_slice
<'a
>(&'a
self) -> &'a
[u8] { unsafe { &*self.data }
}
764 fn verify_decompressed_encoding_version(blob
: &MetadataBlob
, filename
: &Path
)
765 -> Result
<(), String
>
767 let data
= blob
.as_slice_raw();
768 if data
.len() < 4+metadata_encoding_version
.len() ||
769 !<[u8]>::eq(&data
[..4], &[0, 0, 0, 0]) ||
770 &data
[4..4+metadata_encoding_version
.len()] != metadata_encoding_version
772 Err((format
!("incompatible metadata version found: '{}'",
773 filename
.display())))
779 // Just a small wrapper to time how long reading metadata takes.
780 fn get_metadata_section(target
: &Target
, flavor
: CrateFlavor
, filename
: &Path
)
781 -> Result
<MetadataBlob
, String
> {
782 let start
= Instant
::now();
783 let ret
= get_metadata_section_imp(target
, flavor
, filename
);
784 info
!("reading {:?} => {:?}", filename
.file_name().unwrap(),
789 fn get_metadata_section_imp(target
: &Target
, flavor
: CrateFlavor
, filename
: &Path
)
790 -> Result
<MetadataBlob
, String
> {
791 if !filename
.exists() {
792 return Err(format
!("no such file: '{}'", filename
.display()));
794 if flavor
== CrateFlavor
::Rlib
{
795 // Use ArchiveRO for speed here, it's backed by LLVM and uses mmap
796 // internally to read the file. We also avoid even using a memcpy by
797 // just keeping the archive along while the metadata is in use.
798 let archive
= match ArchiveRO
::open(filename
) {
801 debug
!("llvm didn't like `{}`", filename
.display());
802 return Err(format
!("failed to read rlib metadata: '{}'",
803 filename
.display()));
806 return match ArchiveMetadata
::new(archive
).map(|ar
| MetadataArchive(ar
)) {
807 None
=> Err(format
!("failed to read rlib metadata: '{}'",
808 filename
.display())),
810 try
!(verify_decompressed_encoding_version(&blob
, filename
));
816 let buf
= common
::path2cstr(filename
);
817 let mb
= llvm
::LLVMRustCreateMemoryBufferWithContentsOfFile(buf
.as_ptr());
818 if mb
as isize == 0 {
819 return Err(format
!("error reading library: '{}'",
822 let of
= match ObjectFile
::new(mb
) {
825 return Err((format
!("provided path not an object file: '{}'",
826 filename
.display())))
829 let si
= mk_section_iter(of
.llof
);
830 while llvm
::LLVMIsSectionIteratorAtEnd(of
.llof
, si
.llsi
) == False
{
831 let mut name_buf
= ptr
::null();
832 let name_len
= llvm
::LLVMRustGetSectionName(si
.llsi
, &mut name_buf
);
833 let name
= slice
::from_raw_parts(name_buf
as *const u8,
834 name_len
as usize).to_vec();
835 let name
= String
::from_utf8(name
).unwrap();
836 debug
!("get_metadata_section: name {}", name
);
837 if read_meta_section_name(target
) == name
{
838 let cbuf
= llvm
::LLVMGetSectionContents(si
.llsi
);
839 let csz
= llvm
::LLVMGetSectionSize(si
.llsi
) as usize;
840 let cvbuf
: *const u8 = cbuf
as *const u8;
841 let vlen
= metadata_encoding_version
.len();
842 debug
!("checking {} bytes of metadata-version stamp",
844 let minsz
= cmp
::min(vlen
, csz
);
845 let buf0
= slice
::from_raw_parts(cvbuf
, minsz
);
846 let version_ok
= buf0
== metadata_encoding_version
;
848 return Err((format
!("incompatible metadata version found: '{}'",
849 filename
.display())));
852 let cvbuf1
= cvbuf
.offset(vlen
as isize);
853 debug
!("inflating {} bytes of compressed metadata",
855 let bytes
= slice
::from_raw_parts(cvbuf1
, csz
- vlen
);
856 match flate
::inflate_bytes(bytes
) {
858 let blob
= MetadataVec(inflated
);
859 try
!(verify_decompressed_encoding_version(&blob
, filename
));
865 llvm
::LLVMMoveToNextSection(si
.llsi
);
867 Err(format
!("metadata not found: '{}'", filename
.display()))
871 pub fn meta_section_name(target
: &Target
) -> &'
static str {
874 // When using link.exe it was seen that the section name `.note.rustc`
875 // was getting shortened to `.note.ru`, and according to the PE and COFF
878 // > Executable images do not use a string table and do not support
879 // > section names longer than 8 characters
881 // https://msdn.microsoft.com/en-us/library/windows/hardware/gg463119.aspx
883 // As a result, we choose a slightly shorter name! As to why
884 // `.note.rustc` works on MinGW, that's another good question...
886 if target
.options
.is_like_osx
{
893 pub fn read_meta_section_name(_target
: &Target
) -> &'
static str {
897 // A diagnostic function for dumping crate metadata to an output stream
898 pub fn list_file_metadata(target
: &Target
, path
: &Path
,
899 out
: &mut io
::Write
) -> io
::Result
<()> {
900 let filename
= path
.file_name().unwrap().to_str().unwrap();
901 let flavor
= if filename
.ends_with(".rlib") { CrateFlavor::Rlib }
else { CrateFlavor::Dylib }
;
902 match get_metadata_section(target
, flavor
, path
) {
903 Ok(bytes
) => decoder
::list_crate_metadata(bytes
.as_slice(), out
),
905 write
!(out
, "{}\n", msg
)