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 message
= if !self.rejected_via_hash
.is_empty() {
312 format
!("found possibly newer version of crate `{}`",
314 } else if !self.rejected_via_triple
.is_empty() {
315 format
!("couldn't find crate `{}` with expected target triple {}",
316 self.ident
, self.triple
)
317 } else if !self.rejected_via_kind
.is_empty() {
318 format
!("found staticlib `{}` instead of rlib or dylib", self.ident
)
320 format
!("can't find crate for `{}`", self.ident
)
322 let message
= match self.root
{
324 &Some(ref r
) => format
!("{} which `{}` depends on",
327 self.sess
.span_err(self.span
, &message
[..]);
329 if !self.rejected_via_triple
.is_empty() {
330 let mismatches
= self.rejected_via_triple
.iter();
331 for (i
, &CrateMismatch{ ref path, ref got }
) in mismatches
.enumerate() {
332 self.sess
.fileline_note(self.span
,
333 &format
!("crate `{}`, path #{}, triple {}: {}",
334 self.ident
, i
+1, got
, path
.display()));
337 if !self.rejected_via_hash
.is_empty() {
338 self.sess
.span_note(self.span
, "perhaps this crate needs \
340 let mismatches
= self.rejected_via_hash
.iter();
341 for (i
, &CrateMismatch{ ref path, .. }
) in mismatches
.enumerate() {
342 self.sess
.fileline_note(self.span
,
343 &format
!("crate `{}` path #{}: {}",
344 self.ident
, i
+1, path
.display()));
349 for (i
, path
) in r
.paths().iter().enumerate() {
350 self.sess
.fileline_note(self.span
,
351 &format
!("crate `{}` path #{}: {}",
352 r
.ident
, i
+1, path
.display()));
357 if !self.rejected_via_kind
.is_empty() {
358 self.sess
.fileline_help(self.span
, "please recompile this crate using \
360 let mismatches
= self.rejected_via_kind
.iter();
361 for (i
, &CrateMismatch { ref path, .. }
) in mismatches
.enumerate() {
362 self.sess
.fileline_note(self.span
,
363 &format
!("crate `{}` path #{}: {}",
364 self.ident
, i
+1, path
.display()));
367 self.sess
.abort_if_errors();
370 fn find_library_crate(&mut self) -> Option
<Library
> {
371 // If an SVH is specified, then this is a transitive dependency that
372 // must be loaded via -L plus some filtering.
373 if self.hash
.is_none() {
374 self.should_match_name
= false;
375 if let Some(s
) = self.sess
.opts
.externs
.get(self.crate_name
) {
376 return self.find_commandline_library(s
);
378 self.should_match_name
= true;
381 let dypair
= self.dylibname();
383 // want: crate_name.dir_part() + prefix + crate_name.file_part + "-"
384 let dylib_prefix
= format
!("{}{}", dypair
.0, self.crate_name
);
385 let rlib_prefix
= format
!("lib{}", self.crate_name
);
386 let staticlib_prefix
= format
!("lib{}", self.crate_name
);
388 let mut candidates
= HashMap
::new();
389 let mut staticlibs
= vec
!();
391 // First, find all possible candidate rlibs and dylibs purely based on
392 // the name of the files themselves. We're trying to match against an
393 // exact crate name and a possibly an exact hash.
395 // During this step, we can filter all found libraries based on the
396 // name and id found in the crate id (we ignore the path portion for
397 // filename matching), as well as the exact hash (if specified). If we
398 // end up having many candidates, we must look at the metadata to
399 // perform exact matches against hashes/crate ids. Note that opening up
400 // the metadata is where we do an exact match against the full contents
401 // of the crate id (path/name/id).
403 // The goal of this step is to look at as little metadata as possible.
404 self.filesearch
.search(|path
, kind
| {
405 let file
= match path
.file_name().and_then(|s
| s
.to_str()) {
406 None
=> return FileDoesntMatch
,
409 let (hash
, rlib
) = if file
.starts_with(&rlib_prefix
[..]) &&
410 file
.ends_with(".rlib") {
411 (&file
[(rlib_prefix
.len()) .. (file
.len() - ".rlib".len())],
413 } else if file
.starts_with(&dylib_prefix
) &&
414 file
.ends_with(&dypair
.1) {
415 (&file
[(dylib_prefix
.len()) .. (file
.len() - dypair
.1.len())],
418 if file
.starts_with(&staticlib_prefix
[..]) &&
419 file
.ends_with(".a") {
420 staticlibs
.push(CrateMismatch
{
421 path
: path
.to_path_buf(),
422 got
: "static".to_string()
425 return FileDoesntMatch
427 info
!("lib candidate: {}", path
.display());
429 let hash_str
= hash
.to_string();
430 let slot
= candidates
.entry(hash_str
)
431 .or_insert_with(|| (HashMap
::new(), HashMap
::new()));
432 let (ref mut rlibs
, ref mut dylibs
) = *slot
;
433 fs
::canonicalize(path
).map(|p
| {
435 rlibs
.insert(p
, kind
);
437 dylibs
.insert(p
, kind
);
440 }).unwrap_or(FileDoesntMatch
)
442 self.rejected_via_kind
.extend(staticlibs
);
444 // We have now collected all known libraries into a set of candidates
445 // keyed of the filename hash listed. For each filename, we also have a
446 // list of rlibs/dylibs that apply. Here, we map each of these lists
447 // (per hash), to a Library candidate for returning.
449 // A Library candidate is created if the metadata for the set of
450 // libraries corresponds to the crate id and hash criteria that this
451 // search is being performed for.
452 let mut libraries
= Vec
::new();
453 for (_hash
, (rlibs
, dylibs
)) in candidates
{
454 let mut metadata
= None
;
455 let rlib
= self.extract_one(rlibs
, "rlib", &mut metadata
);
456 let dylib
= self.extract_one(dylibs
, "dylib", &mut metadata
);
459 libraries
.push(Library
{
469 // Having now translated all relevant found hashes into libraries, see
470 // what we've got and figure out if we found multiple candidates for
472 match libraries
.len() {
474 1 => Some(libraries
.into_iter().next().unwrap()),
476 self.sess
.span_err(self.span
,
477 &format
!("multiple matching crates for `{}`",
479 self.sess
.note("candidates:");
480 for lib
in &libraries
{
482 Some((ref p
, _
)) => {
483 self.sess
.note(&format
!("path: {}",
489 Some((ref p
, _
)) => {
490 self.sess
.note(&format
!("path: {}",
495 let data
= lib
.metadata
.as_slice();
496 let name
= decoder
::get_crate_name(data
);
497 note_crate_name(self.sess
.diagnostic(), &name
);
504 // Attempts to extract *one* library from the set `m`. If the set has no
505 // elements, `None` is returned. If the set has more than one element, then
506 // the errors and notes are emitted about the set of libraries.
508 // With only one library in the set, this function will extract it, and then
509 // read the metadata from it if `*slot` is `None`. If the metadata couldn't
510 // be read, it is assumed that the file isn't a valid rust library (no
511 // errors are emitted).
512 fn extract_one(&mut self, m
: HashMap
<PathBuf
, PathKind
>, flavor
: &str,
513 slot
: &mut Option
<MetadataBlob
>) -> Option
<(PathBuf
, PathKind
)> {
514 let mut ret
= None
::<(PathBuf
, PathKind
)>;
518 // FIXME(#10786): for an optimization, we only read one of the
519 // library's metadata sections. In theory we should
520 // read both, but reading dylib metadata is quite
524 } else if m
.len() == 1 {
525 return Some(m
.into_iter().next().unwrap())
529 for (lib
, kind
) in m
{
530 info
!("{} reading metadata from: {}", flavor
, lib
.display());
531 let metadata
= match get_metadata_section(self.target
, &lib
) {
533 if self.crate_matches(blob
.as_slice(), &lib
) {
536 info
!("metadata mismatch");
541 info
!("no metadata found");
546 self.sess
.span_err(self.span
,
547 &format
!("multiple {} candidates for `{}` \
551 self.sess
.span_note(self.span
,
552 &format
!(r
"candidate #1: {}",
553 ret
.as_ref().unwrap().0
560 self.sess
.span_note(self.span
,
561 &format
!(r
"candidate #{}: {}", error
,
565 *slot
= Some(metadata
);
566 ret
= Some((lib
, kind
));
568 return if error
> 0 {None}
else {ret}
571 fn crate_matches(&mut self, crate_data
: &[u8], libpath
: &Path
) -> bool
{
572 if self.should_match_name
{
573 match decoder
::maybe_get_crate_name(crate_data
) {
574 Some(ref name
) if self.crate_name
== *name
=> {}
575 _
=> { info!("Rejecting via crate name"); return false }
578 let hash
= match decoder
::maybe_get_crate_hash(crate_data
) {
579 Some(hash
) => hash
, None
=> {
580 info
!("Rejecting via lack of crate hash");
585 let triple
= match decoder
::get_crate_triple(crate_data
) {
586 None
=> { debug!("triple not present"); return false }
589 if triple
!= self.triple
{
590 info
!("Rejecting via crate triple: expected {} got {}", self.triple
, triple
);
591 self.rejected_via_triple
.push(CrateMismatch
{
592 path
: libpath
.to_path_buf(),
593 got
: triple
.to_string()
602 info
!("Rejecting via hash: expected {} got {}", *myhash
, hash
);
603 self.rejected_via_hash
.push(CrateMismatch
{
604 path
: libpath
.to_path_buf(),
605 got
: myhash
.as_str().to_string()
616 // Returns the corresponding (prefix, suffix) that files need to have for
618 fn dylibname(&self) -> (String
, String
) {
619 let t
= &self.target
;
620 (t
.options
.dll_prefix
.clone(), t
.options
.dll_suffix
.clone())
623 fn find_commandline_library(&mut self, locs
: &[String
]) -> Option
<Library
> {
624 // First, filter out all libraries that look suspicious. We only accept
625 // files which actually exist that have the correct naming scheme for
627 let sess
= self.sess
;
628 let dylibname
= self.dylibname();
629 let mut rlibs
= HashMap
::new();
630 let mut dylibs
= HashMap
::new();
632 let locs
= locs
.iter().map(|l
| PathBuf
::from(l
)).filter(|loc
| {
634 sess
.err(&format
!("extern location for {} does not exist: {}",
635 self.crate_name
, loc
.display()));
638 let file
= match loc
.file_name().and_then(|s
| s
.to_str()) {
641 sess
.err(&format
!("extern location for {} is not a file: {}",
642 self.crate_name
, loc
.display()));
646 if file
.starts_with("lib") && file
.ends_with(".rlib") {
649 let (ref prefix
, ref suffix
) = dylibname
;
650 if file
.starts_with(&prefix
[..]) &&
651 file
.ends_with(&suffix
[..]) {
655 sess
.err(&format
!("extern location for {} is of an unknown type: {}",
656 self.crate_name
, loc
.display()));
660 // Now that we have an iterator of good candidates, make sure
661 // there's at most one rlib and at most one dylib.
663 if loc
.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
664 rlibs
.insert(fs
::canonicalize(&loc
).unwrap(),
665 PathKind
::ExternFlag
);
667 dylibs
.insert(fs
::canonicalize(&loc
).unwrap(),
668 PathKind
::ExternFlag
);
673 // Extract the rlib/dylib pair.
674 let mut metadata
= None
;
675 let rlib
= self.extract_one(rlibs
, "rlib", &mut metadata
);
676 let dylib
= self.extract_one(dylibs
, "dylib", &mut metadata
);
678 if rlib
.is_none() && dylib
.is_none() { return None }
680 Some(metadata
) => Some(Library
{
690 pub fn note_crate_name(diag
: &SpanHandler
, name
: &str) {
691 diag
.handler().note(&format
!("crate name: {}", name
));
694 impl ArchiveMetadata
{
695 fn new(ar
: ArchiveRO
) -> Option
<ArchiveMetadata
> {
697 let section
= ar
.iter().find(|sect
| {
698 sect
.name() == Some(METADATA_FILENAME
)
701 Some(s
) => s
.data() as *const [u8],
703 debug
!("didn't find '{}' in the archive", METADATA_FILENAME
);
709 Some(ArchiveMetadata
{
715 pub fn as_slice
<'a
>(&'a
self) -> &'a
[u8] { unsafe { &*self.data }
}
718 // Just a small wrapper to time how long reading metadata takes.
719 fn get_metadata_section(target
: &Target
, filename
: &Path
)
720 -> Result
<MetadataBlob
, String
> {
722 let dur
= Duration
::span(|| {
723 ret
= Some(get_metadata_section_imp(target
, filename
));
725 info
!("reading {:?} => {:?}", filename
.file_name().unwrap(), dur
);
726 return ret
.unwrap();;
729 fn get_metadata_section_imp(target
: &Target
, filename
: &Path
)
730 -> Result
<MetadataBlob
, String
> {
731 if !filename
.exists() {
732 return Err(format
!("no such file: '{}'", filename
.display()));
734 if filename
.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
735 // Use ArchiveRO for speed here, it's backed by LLVM and uses mmap
736 // internally to read the file. We also avoid even using a memcpy by
737 // just keeping the archive along while the metadata is in use.
738 let archive
= match ArchiveRO
::open(filename
) {
741 debug
!("llvm didn't like `{}`", filename
.display());
742 return Err(format
!("failed to read rlib metadata: '{}'",
743 filename
.display()));
746 return match ArchiveMetadata
::new(archive
).map(|ar
| MetadataArchive(ar
)) {
747 None
=> Err(format
!("failed to read rlib metadata: '{}'",
748 filename
.display())),
749 Some(blob
) => Ok(blob
)
753 let buf
= common
::path2cstr(filename
);
754 let mb
= llvm
::LLVMRustCreateMemoryBufferWithContentsOfFile(buf
.as_ptr());
755 if mb
as isize == 0 {
756 return Err(format
!("error reading library: '{}'",
759 let of
= match ObjectFile
::new(mb
) {
762 return Err((format
!("provided path not an object file: '{}'",
763 filename
.display())))
766 let si
= mk_section_iter(of
.llof
);
767 while llvm
::LLVMIsSectionIteratorAtEnd(of
.llof
, si
.llsi
) == False
{
768 let mut name_buf
= ptr
::null();
769 let name_len
= llvm
::LLVMRustGetSectionName(si
.llsi
, &mut name_buf
);
770 let name
= slice
::from_raw_parts(name_buf
as *const u8,
771 name_len
as usize).to_vec();
772 let name
= String
::from_utf8(name
).unwrap();
773 debug
!("get_metadata_section: name {}", name
);
774 if read_meta_section_name(target
) == name
{
775 let cbuf
= llvm
::LLVMGetSectionContents(si
.llsi
);
776 let csz
= llvm
::LLVMGetSectionSize(si
.llsi
) as usize;
777 let cvbuf
: *const u8 = cbuf
as *const u8;
778 let vlen
= encoder
::metadata_encoding_version
.len();
779 debug
!("checking {} bytes of metadata-version stamp",
781 let minsz
= cmp
::min(vlen
, csz
);
782 let buf0
= slice
::from_raw_parts(cvbuf
, minsz
);
783 let version_ok
= buf0
== encoder
::metadata_encoding_version
;
785 return Err((format
!("incompatible metadata version found: '{}'",
786 filename
.display())));
789 let cvbuf1
= cvbuf
.offset(vlen
as isize);
790 debug
!("inflating {} bytes of compressed metadata",
792 let bytes
= slice
::from_raw_parts(cvbuf1
, csz
- vlen
);
793 match flate
::inflate_bytes(bytes
) {
794 Ok(inflated
) => return Ok(MetadataVec(inflated
)),
798 llvm
::LLVMMoveToNextSection(si
.llsi
);
800 Err(format
!("metadata not found: '{}'", filename
.display()))
804 pub fn meta_section_name(target
: &Target
) -> &'
static str {
805 if target
.options
.is_like_osx
{
806 "__DATA,__note.rustc"
807 } else if target
.options
.is_like_msvc
{
808 // When using link.exe it was seen that the section name `.note.rustc`
809 // was getting shortened to `.note.ru`, and according to the PE and COFF
812 // > Executable images do not use a string table and do not support
813 // > section names longer than 8 characters
815 // https://msdn.microsoft.com/en-us/library/windows/hardware/gg463119.aspx
817 // As a result, we choose a slightly shorter name! As to why
818 // `.note.rustc` works on MinGW, that's another good question...
825 pub fn read_meta_section_name(target
: &Target
) -> &'
static str {
826 if target
.options
.is_like_osx
{
828 } else if target
.options
.is_like_msvc
{
835 // A diagnostic function for dumping crate metadata to an output stream
836 pub fn list_file_metadata(target
: &Target
, path
: &Path
,
837 out
: &mut io
::Write
) -> io
::Result
<()> {
838 match get_metadata_section(target
, path
) {
839 Ok(bytes
) => decoder
::list_crate_metadata(bytes
.as_slice(), out
),
841 write
!(out
, "{}\n", msg
)