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!
216 use session
::Session
;
217 use session
::search_paths
::PathKind
;
219 use llvm
::{False, ObjectFile, mk_section_iter}
;
220 use llvm
::archive_ro
::ArchiveRO
;
221 use metadata
::cstore
::{MetadataBlob, MetadataVec, MetadataArchive}
;
222 use metadata
::decoder
;
223 use metadata
::encoder
;
224 use metadata
::filesearch
::{FileSearch, FileMatches, FileDoesntMatch}
;
225 use syntax
::codemap
::Span
;
226 use syntax
::diagnostic
::SpanHandler
;
228 use rustc_back
::target
::Target
;
231 use std
::collections
::HashMap
;
233 use std
::io
::prelude
::*;
235 use std
::path
::{Path, PathBuf}
;
238 use std
::time
::Duration
;
242 pub struct CrateMismatch
{
247 pub struct Context
<'a
> {
248 pub sess
: &'a Session
,
251 pub crate_name
: &'a
str,
252 pub hash
: Option
<&'a Svh
>,
253 // points to either self.sess.target.target or self.sess.host, must match triple
254 pub target
: &'a Target
,
256 pub filesearch
: FileSearch
<'a
>,
257 pub root
: &'a Option
<CratePaths
>,
258 pub rejected_via_hash
: Vec
<CrateMismatch
>,
259 pub rejected_via_triple
: Vec
<CrateMismatch
>,
260 pub rejected_via_kind
: Vec
<CrateMismatch
>,
261 pub should_match_name
: bool
,
265 pub dylib
: Option
<(PathBuf
, PathKind
)>,
266 pub rlib
: Option
<(PathBuf
, PathKind
)>,
267 pub metadata
: MetadataBlob
,
270 pub struct ArchiveMetadata
{
272 // points into self._archive
276 pub struct CratePaths
{
278 pub dylib
: Option
<PathBuf
>,
279 pub rlib
: Option
<PathBuf
>
282 pub const METADATA_FILENAME
: &'
static str = "rust.metadata.bin";
285 fn paths(&self) -> Vec
<PathBuf
> {
286 match (&self.dylib
, &self.rlib
) {
287 (&None
, &None
) => vec
!(),
288 (&Some(ref p
), &None
) |
289 (&None
, &Some(ref p
)) => vec
!(p
.clone()),
290 (&Some(ref p1
), &Some(ref p2
)) => vec
!(p1
.clone(), p2
.clone()),
295 impl<'a
> Context
<'a
> {
296 pub fn maybe_load_library_crate(&mut self) -> Option
<Library
> {
297 self.find_library_crate()
300 pub fn load_library_crate(&mut self) -> Library
{
301 match self.find_library_crate() {
304 self.report_load_errs();
310 pub fn report_load_errs(&mut self) {
311 let add
= match self.root
{
312 &None
=> String
::new(),
313 &Some(ref r
) => format
!(" which `{}` depends on",
316 if !self.rejected_via_hash
.is_empty() {
317 span_err
!(self.sess
, self.span
, E0460
,
318 "found possibly newer version of crate `{}`{}",
320 } else if !self.rejected_via_triple
.is_empty() {
321 span_err
!(self.sess
, self.span
, E0461
,
322 "couldn't find crate `{}` with expected target triple {}{}",
323 self.ident
, self.triple
, add
);
324 } else if !self.rejected_via_kind
.is_empty() {
325 span_err
!(self.sess
, self.span
, E0462
,
326 "found staticlib `{}` instead of rlib or dylib{}",
329 span_err
!(self.sess
, self.span
, E0463
,
330 "can't find crate for `{}`{}",
334 if !self.rejected_via_triple
.is_empty() {
335 let mismatches
= self.rejected_via_triple
.iter();
336 for (i
, &CrateMismatch{ ref path, ref got }
) in mismatches
.enumerate() {
337 self.sess
.fileline_note(self.span
,
338 &format
!("crate `{}`, path #{}, triple {}: {}",
339 self.ident
, i
+1, got
, path
.display()));
342 if !self.rejected_via_hash
.is_empty() {
343 self.sess
.span_note(self.span
, "perhaps this crate needs \
345 let mismatches
= self.rejected_via_hash
.iter();
346 for (i
, &CrateMismatch{ ref path, .. }
) in mismatches
.enumerate() {
347 self.sess
.fileline_note(self.span
,
348 &format
!("crate `{}` path #{}: {}",
349 self.ident
, i
+1, path
.display()));
354 for (i
, path
) in r
.paths().iter().enumerate() {
355 self.sess
.fileline_note(self.span
,
356 &format
!("crate `{}` path #{}: {}",
357 r
.ident
, i
+1, path
.display()));
362 if !self.rejected_via_kind
.is_empty() {
363 self.sess
.fileline_help(self.span
, "please recompile this crate using \
365 let mismatches
= self.rejected_via_kind
.iter();
366 for (i
, &CrateMismatch { ref path, .. }
) in mismatches
.enumerate() {
367 self.sess
.fileline_note(self.span
,
368 &format
!("crate `{}` path #{}: {}",
369 self.ident
, i
+1, path
.display()));
372 self.sess
.abort_if_errors();
375 fn find_library_crate(&mut self) -> Option
<Library
> {
376 // If an SVH is specified, then this is a transitive dependency that
377 // must be loaded via -L plus some filtering.
378 if self.hash
.is_none() {
379 self.should_match_name
= false;
380 if let Some(s
) = self.sess
.opts
.externs
.get(self.crate_name
) {
381 return self.find_commandline_library(s
);
383 self.should_match_name
= true;
386 let dypair
= self.dylibname();
388 // want: crate_name.dir_part() + prefix + crate_name.file_part + "-"
389 let dylib_prefix
= format
!("{}{}", dypair
.0, self.crate_name
);
390 let rlib_prefix
= format
!("lib{}", self.crate_name
);
391 let staticlib_prefix
= format
!("lib{}", self.crate_name
);
393 let mut candidates
= HashMap
::new();
394 let mut staticlibs
= vec
!();
396 // First, find all possible candidate rlibs and dylibs purely based on
397 // the name of the files themselves. We're trying to match against an
398 // exact crate name and a possibly an exact hash.
400 // During this step, we can filter all found libraries based on the
401 // name and id found in the crate id (we ignore the path portion for
402 // filename matching), as well as the exact hash (if specified). If we
403 // end up having many candidates, we must look at the metadata to
404 // perform exact matches against hashes/crate ids. Note that opening up
405 // the metadata is where we do an exact match against the full contents
406 // of the crate id (path/name/id).
408 // The goal of this step is to look at as little metadata as possible.
409 self.filesearch
.search(|path
, kind
| {
410 let file
= match path
.file_name().and_then(|s
| s
.to_str()) {
411 None
=> return FileDoesntMatch
,
414 let (hash
, rlib
) = if file
.starts_with(&rlib_prefix
[..]) &&
415 file
.ends_with(".rlib") {
416 (&file
[(rlib_prefix
.len()) .. (file
.len() - ".rlib".len())],
418 } else if file
.starts_with(&dylib_prefix
) &&
419 file
.ends_with(&dypair
.1) {
420 (&file
[(dylib_prefix
.len()) .. (file
.len() - dypair
.1.len())],
423 if file
.starts_with(&staticlib_prefix
[..]) &&
424 file
.ends_with(".a") {
425 staticlibs
.push(CrateMismatch
{
426 path
: path
.to_path_buf(),
427 got
: "static".to_string()
430 return FileDoesntMatch
432 info
!("lib candidate: {}", path
.display());
434 let hash_str
= hash
.to_string();
435 let slot
= candidates
.entry(hash_str
)
436 .or_insert_with(|| (HashMap
::new(), HashMap
::new()));
437 let (ref mut rlibs
, ref mut dylibs
) = *slot
;
438 fs
::canonicalize(path
).map(|p
| {
440 rlibs
.insert(p
, kind
);
442 dylibs
.insert(p
, kind
);
445 }).unwrap_or(FileDoesntMatch
)
447 self.rejected_via_kind
.extend(staticlibs
);
449 // We have now collected all known libraries into a set of candidates
450 // keyed of the filename hash listed. For each filename, we also have a
451 // list of rlibs/dylibs that apply. Here, we map each of these lists
452 // (per hash), to a Library candidate for returning.
454 // A Library candidate is created if the metadata for the set of
455 // libraries corresponds to the crate id and hash criteria that this
456 // search is being performed for.
457 let mut libraries
= Vec
::new();
458 for (_hash
, (rlibs
, dylibs
)) in candidates
{
459 let mut metadata
= None
;
460 let rlib
= self.extract_one(rlibs
, "rlib", &mut metadata
);
461 let dylib
= self.extract_one(dylibs
, "dylib", &mut metadata
);
464 libraries
.push(Library
{
474 // Having now translated all relevant found hashes into libraries, see
475 // what we've got and figure out if we found multiple candidates for
477 match libraries
.len() {
479 1 => Some(libraries
.into_iter().next().unwrap()),
481 span_err
!(self.sess
, self.span
, E0464
,
482 "multiple matching crates for `{}`",
484 self.sess
.note("candidates:");
485 for lib
in &libraries
{
487 Some((ref p
, _
)) => {
488 self.sess
.note(&format
!("path: {}",
494 Some((ref p
, _
)) => {
495 self.sess
.note(&format
!("path: {}",
500 let data
= lib
.metadata
.as_slice();
501 let name
= decoder
::get_crate_name(data
);
502 note_crate_name(self.sess
.diagnostic(), &name
);
509 // Attempts to extract *one* library from the set `m`. If the set has no
510 // elements, `None` is returned. If the set has more than one element, then
511 // the errors and notes are emitted about the set of libraries.
513 // With only one library in the set, this function will extract it, and then
514 // read the metadata from it if `*slot` is `None`. If the metadata couldn't
515 // be read, it is assumed that the file isn't a valid rust library (no
516 // errors are emitted).
517 fn extract_one(&mut self, m
: HashMap
<PathBuf
, PathKind
>, flavor
: &str,
518 slot
: &mut Option
<MetadataBlob
>) -> Option
<(PathBuf
, PathKind
)> {
519 let mut ret
= None
::<(PathBuf
, PathKind
)>;
523 // FIXME(#10786): for an optimization, we only read one of the
524 // library's metadata sections. In theory we should
525 // read both, but reading dylib metadata is quite
529 } else if m
.len() == 1 {
530 return Some(m
.into_iter().next().unwrap())
534 for (lib
, kind
) in m
{
535 info
!("{} reading metadata from: {}", flavor
, lib
.display());
536 let metadata
= match get_metadata_section(self.target
, &lib
) {
538 if self.crate_matches(blob
.as_slice(), &lib
) {
541 info
!("metadata mismatch");
546 info
!("no metadata found");
551 span_err
!(self.sess
, self.span
, E0465
,
552 "multiple {} candidates for `{}` found",
553 flavor
, self.crate_name
);
554 self.sess
.span_note(self.span
,
555 &format
!(r
"candidate #1: {}",
556 ret
.as_ref().unwrap().0
563 self.sess
.span_note(self.span
,
564 &format
!(r
"candidate #{}: {}", error
,
568 *slot
= Some(metadata
);
569 ret
= Some((lib
, kind
));
571 return if error
> 0 {None}
else {ret}
574 fn crate_matches(&mut self, crate_data
: &[u8], libpath
: &Path
) -> bool
{
575 if self.should_match_name
{
576 match decoder
::maybe_get_crate_name(crate_data
) {
577 Some(ref name
) if self.crate_name
== *name
=> {}
578 _
=> { info!("Rejecting via crate name"); return false }
581 let hash
= match decoder
::maybe_get_crate_hash(crate_data
) {
582 Some(hash
) => hash
, None
=> {
583 info
!("Rejecting via lack of crate hash");
588 let triple
= match decoder
::get_crate_triple(crate_data
) {
589 None
=> { debug!("triple not present"); return false }
592 if triple
!= self.triple
{
593 info
!("Rejecting via crate triple: expected {} got {}", self.triple
, triple
);
594 self.rejected_via_triple
.push(CrateMismatch
{
595 path
: libpath
.to_path_buf(),
596 got
: triple
.to_string()
605 info
!("Rejecting via hash: expected {} got {}", *myhash
, hash
);
606 self.rejected_via_hash
.push(CrateMismatch
{
607 path
: libpath
.to_path_buf(),
608 got
: myhash
.as_str().to_string()
619 // Returns the corresponding (prefix, suffix) that files need to have for
621 fn dylibname(&self) -> (String
, String
) {
622 let t
= &self.target
;
623 (t
.options
.dll_prefix
.clone(), t
.options
.dll_suffix
.clone())
626 fn find_commandline_library(&mut self, locs
: &[String
]) -> Option
<Library
> {
627 // First, filter out all libraries that look suspicious. We only accept
628 // files which actually exist that have the correct naming scheme for
630 let sess
= self.sess
;
631 let dylibname
= self.dylibname();
632 let mut rlibs
= HashMap
::new();
633 let mut dylibs
= HashMap
::new();
635 let locs
= locs
.iter().map(|l
| PathBuf
::from(l
)).filter(|loc
| {
637 sess
.err(&format
!("extern location for {} does not exist: {}",
638 self.crate_name
, loc
.display()));
641 let file
= match loc
.file_name().and_then(|s
| s
.to_str()) {
644 sess
.err(&format
!("extern location for {} is not a file: {}",
645 self.crate_name
, loc
.display()));
649 if file
.starts_with("lib") && file
.ends_with(".rlib") {
652 let (ref prefix
, ref suffix
) = dylibname
;
653 if file
.starts_with(&prefix
[..]) &&
654 file
.ends_with(&suffix
[..]) {
658 sess
.err(&format
!("extern location for {} is of an unknown type: {}",
659 self.crate_name
, loc
.display()));
663 // Now that we have an iterator of good candidates, make sure
664 // there's at most one rlib and at most one dylib.
666 if loc
.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
667 rlibs
.insert(fs
::canonicalize(&loc
).unwrap(),
668 PathKind
::ExternFlag
);
670 dylibs
.insert(fs
::canonicalize(&loc
).unwrap(),
671 PathKind
::ExternFlag
);
676 // Extract the rlib/dylib pair.
677 let mut metadata
= None
;
678 let rlib
= self.extract_one(rlibs
, "rlib", &mut metadata
);
679 let dylib
= self.extract_one(dylibs
, "dylib", &mut metadata
);
681 if rlib
.is_none() && dylib
.is_none() { return None }
683 Some(metadata
) => Some(Library
{
693 pub fn note_crate_name(diag
: &SpanHandler
, name
: &str) {
694 diag
.handler().note(&format
!("crate name: {}", name
));
697 impl ArchiveMetadata
{
698 fn new(ar
: ArchiveRO
) -> Option
<ArchiveMetadata
> {
700 let section
= ar
.iter().find(|sect
| {
701 sect
.name() == Some(METADATA_FILENAME
)
704 Some(s
) => s
.data() as *const [u8],
706 debug
!("didn't find '{}' in the archive", METADATA_FILENAME
);
712 Some(ArchiveMetadata
{
718 pub fn as_slice
<'a
>(&'a
self) -> &'a
[u8] { unsafe { &*self.data }
}
721 // Just a small wrapper to time how long reading metadata takes.
722 fn get_metadata_section(target
: &Target
, filename
: &Path
)
723 -> Result
<MetadataBlob
, String
> {
725 let dur
= Duration
::span(|| {
726 ret
= Some(get_metadata_section_imp(target
, filename
));
728 info
!("reading {:?} => {:?}", filename
.file_name().unwrap(), dur
);
732 fn get_metadata_section_imp(target
: &Target
, filename
: &Path
)
733 -> Result
<MetadataBlob
, String
> {
734 if !filename
.exists() {
735 return Err(format
!("no such file: '{}'", filename
.display()));
737 if filename
.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
738 // Use ArchiveRO for speed here, it's backed by LLVM and uses mmap
739 // internally to read the file. We also avoid even using a memcpy by
740 // just keeping the archive along while the metadata is in use.
741 let archive
= match ArchiveRO
::open(filename
) {
744 debug
!("llvm didn't like `{}`", filename
.display());
745 return Err(format
!("failed to read rlib metadata: '{}'",
746 filename
.display()));
749 return match ArchiveMetadata
::new(archive
).map(|ar
| MetadataArchive(ar
)) {
750 None
=> Err(format
!("failed to read rlib metadata: '{}'",
751 filename
.display())),
752 Some(blob
) => Ok(blob
)
756 let buf
= common
::path2cstr(filename
);
757 let mb
= llvm
::LLVMRustCreateMemoryBufferWithContentsOfFile(buf
.as_ptr());
758 if mb
as isize == 0 {
759 return Err(format
!("error reading library: '{}'",
762 let of
= match ObjectFile
::new(mb
) {
765 return Err((format
!("provided path not an object file: '{}'",
766 filename
.display())))
769 let si
= mk_section_iter(of
.llof
);
770 while llvm
::LLVMIsSectionIteratorAtEnd(of
.llof
, si
.llsi
) == False
{
771 let mut name_buf
= ptr
::null();
772 let name_len
= llvm
::LLVMRustGetSectionName(si
.llsi
, &mut name_buf
);
773 let name
= slice
::from_raw_parts(name_buf
as *const u8,
774 name_len
as usize).to_vec();
775 let name
= String
::from_utf8(name
).unwrap();
776 debug
!("get_metadata_section: name {}", name
);
777 if read_meta_section_name(target
) == name
{
778 let cbuf
= llvm
::LLVMGetSectionContents(si
.llsi
);
779 let csz
= llvm
::LLVMGetSectionSize(si
.llsi
) as usize;
780 let cvbuf
: *const u8 = cbuf
as *const u8;
781 let vlen
= encoder
::metadata_encoding_version
.len();
782 debug
!("checking {} bytes of metadata-version stamp",
784 let minsz
= cmp
::min(vlen
, csz
);
785 let buf0
= slice
::from_raw_parts(cvbuf
, minsz
);
786 let version_ok
= buf0
== encoder
::metadata_encoding_version
;
788 return Err((format
!("incompatible metadata version found: '{}'",
789 filename
.display())));
792 let cvbuf1
= cvbuf
.offset(vlen
as isize);
793 debug
!("inflating {} bytes of compressed metadata",
795 let bytes
= slice
::from_raw_parts(cvbuf1
, csz
- vlen
);
796 match flate
::inflate_bytes(bytes
) {
797 Ok(inflated
) => return Ok(MetadataVec(inflated
)),
801 llvm
::LLVMMoveToNextSection(si
.llsi
);
803 Err(format
!("metadata not found: '{}'", filename
.display()))
807 pub fn meta_section_name(target
: &Target
) -> &'
static str {
808 if target
.options
.is_like_osx
{
809 "__DATA,__note.rustc"
810 } else if target
.options
.is_like_msvc
{
811 // When using link.exe it was seen that the section name `.note.rustc`
812 // was getting shortened to `.note.ru`, and according to the PE and COFF
815 // > Executable images do not use a string table and do not support
816 // > section names longer than 8 characters
818 // https://msdn.microsoft.com/en-us/library/windows/hardware/gg463119.aspx
820 // As a result, we choose a slightly shorter name! As to why
821 // `.note.rustc` works on MinGW, that's another good question...
828 pub fn read_meta_section_name(target
: &Target
) -> &'
static str {
829 if target
.options
.is_like_osx
{
831 } else if target
.options
.is_like_msvc
{
838 // A diagnostic function for dumping crate metadata to an output stream
839 pub fn list_file_metadata(target
: &Target
, path
: &Path
,
840 out
: &mut io
::Write
) -> io
::Result
<()> {
841 match get_metadata_section(target
, path
) {
842 Ok(bytes
) => decoder
::list_crate_metadata(bytes
.as_slice(), out
),
844 write
!(out
, "{}\n", msg
)