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 back
::archive
::METADATA_FILENAME
;
217 use session
::Session
;
218 use session
::search_paths
::PathKind
;
220 use llvm
::{False, ObjectFile, mk_section_iter}
;
221 use llvm
::archive_ro
::ArchiveRO
;
222 use metadata
::cstore
::{MetadataBlob, MetadataVec, MetadataArchive}
;
223 use metadata
::decoder
;
224 use metadata
::encoder
;
225 use metadata
::filesearch
::{FileSearch, FileMatches, FileDoesntMatch}
;
226 use syntax
::codemap
::Span
;
227 use syntax
::diagnostic
::SpanHandler
;
229 use rustc_back
::target
::Target
;
232 use std
::collections
::HashMap
;
234 use std
::io
::prelude
::*;
236 use std
::path
::{Path, PathBuf}
;
239 use std
::time
::Duration
;
243 pub struct CrateMismatch
{
248 pub struct Context
<'a
> {
249 pub sess
: &'a Session
,
252 pub crate_name
: &'a
str,
253 pub hash
: Option
<&'a Svh
>,
254 // points to either self.sess.target.target or self.sess.host, must match triple
255 pub target
: &'a Target
,
257 pub filesearch
: FileSearch
<'a
>,
258 pub root
: &'a Option
<CratePaths
>,
259 pub rejected_via_hash
: Vec
<CrateMismatch
>,
260 pub rejected_via_triple
: Vec
<CrateMismatch
>,
261 pub rejected_via_kind
: Vec
<CrateMismatch
>,
262 pub should_match_name
: bool
,
266 pub dylib
: Option
<(PathBuf
, PathKind
)>,
267 pub rlib
: Option
<(PathBuf
, PathKind
)>,
268 pub metadata
: MetadataBlob
,
271 pub struct ArchiveMetadata
{
273 // points into self._archive
277 pub struct CratePaths
{
279 pub dylib
: Option
<PathBuf
>,
280 pub rlib
: Option
<PathBuf
>
284 fn paths(&self) -> Vec
<PathBuf
> {
285 match (&self.dylib
, &self.rlib
) {
286 (&None
, &None
) => vec
!(),
287 (&Some(ref p
), &None
) |
288 (&None
, &Some(ref p
)) => vec
!(p
.clone()),
289 (&Some(ref p1
), &Some(ref p2
)) => vec
!(p1
.clone(), p2
.clone()),
294 impl<'a
> Context
<'a
> {
295 pub fn maybe_load_library_crate(&mut self) -> Option
<Library
> {
296 self.find_library_crate()
299 pub fn load_library_crate(&mut self) -> Library
{
300 match self.find_library_crate() {
303 self.report_load_errs();
309 pub fn report_load_errs(&mut self) {
310 let message
= if !self.rejected_via_hash
.is_empty() {
311 format
!("found possibly newer version of crate `{}`",
313 } else if !self.rejected_via_triple
.is_empty() {
314 format
!("couldn't find crate `{}` with expected target triple {}",
315 self.ident
, self.triple
)
316 } else if !self.rejected_via_kind
.is_empty() {
317 format
!("found staticlib `{}` instead of rlib or dylib", self.ident
)
319 format
!("can't find crate for `{}`", self.ident
)
321 let message
= match self.root
{
323 &Some(ref r
) => format
!("{} which `{}` depends on",
326 self.sess
.span_err(self.span
, &message
[..]);
328 if !self.rejected_via_triple
.is_empty() {
329 let mismatches
= self.rejected_via_triple
.iter();
330 for (i
, &CrateMismatch{ ref path, ref got }
) in mismatches
.enumerate() {
331 self.sess
.fileline_note(self.span
,
332 &format
!("crate `{}`, path #{}, triple {}: {}",
333 self.ident
, i
+1, got
, path
.display()));
336 if !self.rejected_via_hash
.is_empty() {
337 self.sess
.span_note(self.span
, "perhaps this crate needs \
339 let mismatches
= self.rejected_via_hash
.iter();
340 for (i
, &CrateMismatch{ ref path, .. }
) in mismatches
.enumerate() {
341 self.sess
.fileline_note(self.span
,
342 &format
!("crate `{}` path #{}: {}",
343 self.ident
, i
+1, path
.display()));
348 for (i
, path
) in r
.paths().iter().enumerate() {
349 self.sess
.fileline_note(self.span
,
350 &format
!("crate `{}` path #{}: {}",
351 r
.ident
, i
+1, path
.display()));
356 if !self.rejected_via_kind
.is_empty() {
357 self.sess
.fileline_help(self.span
, "please recompile this crate using \
359 let mismatches
= self.rejected_via_kind
.iter();
360 for (i
, &CrateMismatch { ref path, .. }
) in mismatches
.enumerate() {
361 self.sess
.fileline_note(self.span
,
362 &format
!("crate `{}` path #{}: {}",
363 self.ident
, i
+1, path
.display()));
366 self.sess
.abort_if_errors();
369 fn find_library_crate(&mut self) -> Option
<Library
> {
370 // If an SVH is specified, then this is a transitive dependency that
371 // must be loaded via -L plus some filtering.
372 if self.hash
.is_none() {
373 self.should_match_name
= false;
374 if let Some(s
) = self.sess
.opts
.externs
.get(self.crate_name
) {
375 return self.find_commandline_library(s
);
377 self.should_match_name
= true;
380 let dypair
= self.dylibname();
382 // want: crate_name.dir_part() + prefix + crate_name.file_part + "-"
383 let dylib_prefix
= format
!("{}{}", dypair
.0, self.crate_name
);
384 let rlib_prefix
= format
!("lib{}", self.crate_name
);
385 let staticlib_prefix
= format
!("lib{}", self.crate_name
);
387 let mut candidates
= HashMap
::new();
388 let mut staticlibs
= vec
!();
390 // First, find all possible candidate rlibs and dylibs purely based on
391 // the name of the files themselves. We're trying to match against an
392 // exact crate name and a possibly an exact hash.
394 // During this step, we can filter all found libraries based on the
395 // name and id found in the crate id (we ignore the path portion for
396 // filename matching), as well as the exact hash (if specified). If we
397 // end up having many candidates, we must look at the metadata to
398 // perform exact matches against hashes/crate ids. Note that opening up
399 // the metadata is where we do an exact match against the full contents
400 // of the crate id (path/name/id).
402 // The goal of this step is to look at as little metadata as possible.
403 self.filesearch
.search(|path
, kind
| {
404 let file
= match path
.file_name().and_then(|s
| s
.to_str()) {
405 None
=> return FileDoesntMatch
,
408 let (hash
, rlib
) = if file
.starts_with(&rlib_prefix
[..]) &&
409 file
.ends_with(".rlib") {
410 (&file
[(rlib_prefix
.len()) .. (file
.len() - ".rlib".len())],
412 } else if file
.starts_with(&dylib_prefix
) &&
413 file
.ends_with(&dypair
.1) {
414 (&file
[(dylib_prefix
.len()) .. (file
.len() - dypair
.1.len())],
417 if file
.starts_with(&staticlib_prefix
[..]) &&
418 file
.ends_with(".a") {
419 staticlibs
.push(CrateMismatch
{
420 path
: path
.to_path_buf(),
421 got
: "static".to_string()
424 return FileDoesntMatch
426 info
!("lib candidate: {}", path
.display());
428 let hash_str
= hash
.to_string();
429 let slot
= candidates
.entry(hash_str
)
430 .or_insert_with(|| (HashMap
::new(), HashMap
::new()));
431 let (ref mut rlibs
, ref mut dylibs
) = *slot
;
433 rlibs
.insert(fs
::canonicalize(path
).unwrap(), kind
);
435 dylibs
.insert(fs
::canonicalize(path
).unwrap(), kind
);
440 self.rejected_via_kind
.extend(staticlibs
.into_iter());
442 // We have now collected all known libraries into a set of candidates
443 // keyed of the filename hash listed. For each filename, we also have a
444 // list of rlibs/dylibs that apply. Here, we map each of these lists
445 // (per hash), to a Library candidate for returning.
447 // A Library candidate is created if the metadata for the set of
448 // libraries corresponds to the crate id and hash criteria that this
449 // search is being performed for.
450 let mut libraries
= Vec
::new();
451 for (_hash
, (rlibs
, dylibs
)) in candidates
{
452 let mut metadata
= None
;
453 let rlib
= self.extract_one(rlibs
, "rlib", &mut metadata
);
454 let dylib
= self.extract_one(dylibs
, "dylib", &mut metadata
);
457 libraries
.push(Library
{
467 // Having now translated all relevant found hashes into libraries, see
468 // what we've got and figure out if we found multiple candidates for
470 match libraries
.len() {
472 1 => Some(libraries
.into_iter().next().unwrap()),
474 self.sess
.span_err(self.span
,
475 &format
!("multiple matching crates for `{}`",
477 self.sess
.note("candidates:");
478 for lib
in &libraries
{
480 Some((ref p
, _
)) => {
481 self.sess
.note(&format
!("path: {}",
487 Some((ref p
, _
)) => {
488 self.sess
.note(&format
!("path: {}",
493 let data
= lib
.metadata
.as_slice();
494 let name
= decoder
::get_crate_name(data
);
495 note_crate_name(self.sess
.diagnostic(), &name
);
502 // Attempts to extract *one* library from the set `m`. If the set has no
503 // elements, `None` is returned. If the set has more than one element, then
504 // the errors and notes are emitted about the set of libraries.
506 // With only one library in the set, this function will extract it, and then
507 // read the metadata from it if `*slot` is `None`. If the metadata couldn't
508 // be read, it is assumed that the file isn't a valid rust library (no
509 // errors are emitted).
510 fn extract_one(&mut self, m
: HashMap
<PathBuf
, PathKind
>, flavor
: &str,
511 slot
: &mut Option
<MetadataBlob
>) -> Option
<(PathBuf
, PathKind
)> {
512 let mut ret
= None
::<(PathBuf
, PathKind
)>;
516 // FIXME(#10786): for an optimization, we only read one of the
517 // library's metadata sections. In theory we should
518 // read both, but reading dylib metadata is quite
522 } else if m
.len() == 1 {
523 return Some(m
.into_iter().next().unwrap())
527 for (lib
, kind
) in m
{
528 info
!("{} reading metadata from: {}", flavor
, lib
.display());
529 let metadata
= match get_metadata_section(self.target
.options
.is_like_osx
,
532 if self.crate_matches(blob
.as_slice(), &lib
) {
535 info
!("metadata mismatch");
540 info
!("no metadata found");
545 self.sess
.span_err(self.span
,
546 &format
!("multiple {} candidates for `{}` \
550 self.sess
.span_note(self.span
,
551 &format
!(r
"candidate #1: {}",
552 ret
.as_ref().unwrap().0
559 self.sess
.span_note(self.span
,
560 &format
!(r
"candidate #{}: {}", error
,
564 *slot
= Some(metadata
);
565 ret
= Some((lib
, kind
));
567 return if error
> 0 {None}
else {ret}
570 fn crate_matches(&mut self, crate_data
: &[u8], libpath
: &Path
) -> bool
{
571 if self.should_match_name
{
572 match decoder
::maybe_get_crate_name(crate_data
) {
573 Some(ref name
) if self.crate_name
== *name
=> {}
574 _
=> { info!("Rejecting via crate name"); return false }
577 let hash
= match decoder
::maybe_get_crate_hash(crate_data
) {
578 Some(hash
) => hash
, None
=> {
579 info
!("Rejecting via lack of crate hash");
584 let triple
= match decoder
::get_crate_triple(crate_data
) {
585 None
=> { debug!("triple not present"); return false }
588 if triple
!= self.triple
{
589 info
!("Rejecting via crate triple: expected {} got {}", self.triple
, triple
);
590 self.rejected_via_triple
.push(CrateMismatch
{
591 path
: libpath
.to_path_buf(),
592 got
: triple
.to_string()
601 info
!("Rejecting via hash: expected {} got {}", *myhash
, hash
);
602 self.rejected_via_hash
.push(CrateMismatch
{
603 path
: libpath
.to_path_buf(),
604 got
: myhash
.as_str().to_string()
615 // Returns the corresponding (prefix, suffix) that files need to have for
617 fn dylibname(&self) -> (String
, String
) {
618 let t
= &self.target
;
619 (t
.options
.dll_prefix
.clone(), t
.options
.dll_suffix
.clone())
622 fn find_commandline_library(&mut self, locs
: &[String
]) -> Option
<Library
> {
623 // First, filter out all libraries that look suspicious. We only accept
624 // files which actually exist that have the correct naming scheme for
626 let sess
= self.sess
;
627 let dylibname
= self.dylibname();
628 let mut rlibs
= HashMap
::new();
629 let mut dylibs
= HashMap
::new();
631 let locs
= locs
.iter().map(|l
| PathBuf
::from(l
)).filter(|loc
| {
633 sess
.err(&format
!("extern location for {} does not exist: {}",
634 self.crate_name
, loc
.display()));
637 let file
= match loc
.file_name().and_then(|s
| s
.to_str()) {
640 sess
.err(&format
!("extern location for {} is not a file: {}",
641 self.crate_name
, loc
.display()));
645 if file
.starts_with("lib") && file
.ends_with(".rlib") {
648 let (ref prefix
, ref suffix
) = dylibname
;
649 if file
.starts_with(&prefix
[..]) &&
650 file
.ends_with(&suffix
[..]) {
654 sess
.err(&format
!("extern location for {} is of an unknown type: {}",
655 self.crate_name
, loc
.display()));
659 // Now that we have an iterator of good candidates, make sure
660 // there's at most one rlib and at most one dylib.
662 if loc
.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
663 rlibs
.insert(fs
::canonicalize(&loc
).unwrap(),
664 PathKind
::ExternFlag
);
666 dylibs
.insert(fs
::canonicalize(&loc
).unwrap(),
667 PathKind
::ExternFlag
);
672 // Extract the rlib/dylib pair.
673 let mut metadata
= None
;
674 let rlib
= self.extract_one(rlibs
, "rlib", &mut metadata
);
675 let dylib
= self.extract_one(dylibs
, "dylib", &mut metadata
);
677 if rlib
.is_none() && dylib
.is_none() { return None }
679 Some(metadata
) => Some(Library
{
689 pub fn note_crate_name(diag
: &SpanHandler
, name
: &str) {
690 diag
.handler().note(&format
!("crate name: {}", name
));
693 impl ArchiveMetadata
{
694 fn new(ar
: ArchiveRO
) -> Option
<ArchiveMetadata
> {
696 let section
= ar
.iter().find(|sect
| {
697 sect
.name() == Some(METADATA_FILENAME
)
700 Some(s
) => s
.data() as *const [u8],
702 debug
!("didn't find '{}' in the archive", METADATA_FILENAME
);
708 Some(ArchiveMetadata
{
714 pub fn as_slice
<'a
>(&'a
self) -> &'a
[u8] { unsafe { &*self.data }
}
717 // Just a small wrapper to time how long reading metadata takes.
718 fn get_metadata_section(is_osx
: bool
, filename
: &Path
) -> Result
<MetadataBlob
, String
> {
720 let dur
= Duration
::span(|| {
721 ret
= Some(get_metadata_section_imp(is_osx
, filename
));
723 info
!("reading {:?} => {}", filename
.file_name().unwrap(), dur
);
724 return ret
.unwrap();;
727 fn get_metadata_section_imp(is_osx
: bool
, filename
: &Path
) -> Result
<MetadataBlob
, String
> {
728 if !filename
.exists() {
729 return Err(format
!("no such file: '{}'", filename
.display()));
731 if filename
.file_name().unwrap().to_str().unwrap().ends_with(".rlib") {
732 // Use ArchiveRO for speed here, it's backed by LLVM and uses mmap
733 // internally to read the file. We also avoid even using a memcpy by
734 // just keeping the archive along while the metadata is in use.
735 let archive
= match ArchiveRO
::open(filename
) {
738 debug
!("llvm didn't like `{}`", filename
.display());
739 return Err(format
!("failed to read rlib metadata: '{}'",
740 filename
.display()));
743 return match ArchiveMetadata
::new(archive
).map(|ar
| MetadataArchive(ar
)) {
744 None
=> Err(format
!("failed to read rlib metadata: '{}'",
745 filename
.display())),
746 Some(blob
) => Ok(blob
)
750 let buf
= common
::path2cstr(filename
);
751 let mb
= llvm
::LLVMRustCreateMemoryBufferWithContentsOfFile(buf
.as_ptr());
752 if mb
as isize == 0 {
753 return Err(format
!("error reading library: '{}'",
756 let of
= match ObjectFile
::new(mb
) {
759 return Err((format
!("provided path not an object file: '{}'",
760 filename
.display())))
763 let si
= mk_section_iter(of
.llof
);
764 while llvm
::LLVMIsSectionIteratorAtEnd(of
.llof
, si
.llsi
) == False
{
765 let mut name_buf
= ptr
::null();
766 let name_len
= llvm
::LLVMRustGetSectionName(si
.llsi
, &mut name_buf
);
767 let name
= slice
::from_raw_parts(name_buf
as *const u8,
768 name_len
as usize).to_vec();
769 let name
= String
::from_utf8(name
).unwrap();
770 debug
!("get_metadata_section: name {}", name
);
771 if read_meta_section_name(is_osx
) == name
{
772 let cbuf
= llvm
::LLVMGetSectionContents(si
.llsi
);
773 let csz
= llvm
::LLVMGetSectionSize(si
.llsi
) as usize;
774 let cvbuf
: *const u8 = cbuf
as *const u8;
775 let vlen
= encoder
::metadata_encoding_version
.len();
776 debug
!("checking {} bytes of metadata-version stamp",
778 let minsz
= cmp
::min(vlen
, csz
);
779 let buf0
= slice
::from_raw_parts(cvbuf
, minsz
);
780 let version_ok
= buf0
== encoder
::metadata_encoding_version
;
782 return Err((format
!("incompatible metadata version found: '{}'",
783 filename
.display())));
786 let cvbuf1
= cvbuf
.offset(vlen
as isize);
787 debug
!("inflating {} bytes of compressed metadata",
789 let bytes
= slice
::from_raw_parts(cvbuf1
, csz
- vlen
);
790 match flate
::inflate_bytes(bytes
) {
791 Ok(inflated
) => return Ok(MetadataVec(inflated
)),
795 llvm
::LLVMMoveToNextSection(si
.llsi
);
797 Err(format
!("metadata not found: '{}'", filename
.display()))
801 pub fn meta_section_name(is_osx
: bool
) -> &'
static str {
803 "__DATA,__note.rustc"
809 pub fn read_meta_section_name(is_osx
: bool
) -> &'
static str {
817 // A diagnostic function for dumping crate metadata to an output stream
818 pub fn list_file_metadata(is_osx
: bool
, path
: &Path
,
819 out
: &mut io
::Write
) -> io
::Result
<()> {
820 match get_metadata_section(is_osx
, path
) {
821 Ok(bytes
) => decoder
::list_crate_metadata(bytes
.as_slice(), out
),
823 write
!(out
, "{}\n", msg
)