// Copyright 2017 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir; use rustc::middle::cstore::{self, NativeLibrary}; use rustc::session::Session; use rustc::ty::TyCtxt; use rustc::util::nodemap::FxHashSet; use rustc_target::spec::abi::Abi; use syntax::attr; use syntax::codemap::Span; use syntax::feature_gate::{self, GateIssue}; use syntax::symbol::Symbol; pub fn collect<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Vec { let mut collector = Collector { tcx, libs: Vec::new(), }; tcx.hir.krate().visit_all_item_likes(&mut collector); collector.process_command_line(); return collector.libs } pub fn relevant_lib(sess: &Session, lib: &NativeLibrary) -> bool { match lib.cfg { Some(ref cfg) => attr::cfg_matches(cfg, &sess.parse_sess, None), None => true, } } struct Collector<'a, 'tcx: 'a> { tcx: TyCtxt<'a, 'tcx, 'tcx>, libs: Vec, } impl<'a, 'tcx> ItemLikeVisitor<'tcx> for Collector<'a, 'tcx> { fn visit_item(&mut self, it: &'tcx hir::Item) { let fm = match it.node { hir::ItemKind::ForeignMod(ref fm) => fm, _ => return, }; if fm.abi == Abi::Rust || fm.abi == Abi::RustIntrinsic || fm.abi == Abi::PlatformIntrinsic { return } // Process all of the #[link(..)]-style arguments for m in it.attrs.iter().filter(|a| a.check_name("link")) { let items = match m.meta_item_list() { Some(item) => item, None => continue, }; let kind = items.iter().find(|k| { k.check_name("kind") }).and_then(|a| a.value_str()).map(Symbol::as_str); let kind = match kind.as_ref().map(|s| &s[..]) { Some("static") => cstore::NativeStatic, Some("static-nobundle") => cstore::NativeStaticNobundle, Some("dylib") => cstore::NativeUnknown, Some("framework") => cstore::NativeFramework, Some(k) => { struct_span_err!(self.tcx.sess, m.span, E0458, "unknown kind: `{}`", k) .span_label(m.span, "unknown kind").emit(); cstore::NativeUnknown } None => cstore::NativeUnknown }; let n = items.iter().find(|n| { n.check_name("name") }).and_then(|a| a.value_str()); let n = match n { Some(n) => n, None => { struct_span_err!(self.tcx.sess, m.span, E0459, "#[link(...)] specified without `name = \"foo\"`") .span_label(m.span, "missing `name` argument").emit(); Symbol::intern("foo") } }; let cfg = items.iter().find(|k| { k.check_name("cfg") }).and_then(|a| a.meta_item_list()); let cfg = if let Some(list) = cfg { if list.is_empty() { self.tcx.sess.span_err(m.span(), "`cfg()` must have an argument"); return; } else if let cfg @ Some(..) = list[0].meta_item() { cfg.cloned() } else { self.tcx.sess.span_err(list[0].span(), "invalid argument for `cfg(..)`"); return; } } else { None }; let lib = NativeLibrary { name: n, kind, cfg, foreign_module: Some(self.tcx.hir.local_def_id(it.id)), }; self.register_native_lib(Some(m.span), lib); } } fn visit_trait_item(&mut self, _it: &'tcx hir::TraitItem) {} fn visit_impl_item(&mut self, _it: &'tcx hir::ImplItem) {} } impl<'a, 'tcx> Collector<'a, 'tcx> { fn register_native_lib(&mut self, span: Option, lib: NativeLibrary) { if lib.name.as_str().is_empty() { match span { Some(span) => { struct_span_err!(self.tcx.sess, span, E0454, "#[link(name = \"\")] given with empty name") .span_label(span, "empty name given") .emit(); } None => { self.tcx.sess.err("empty library name given via `-l`"); } } return } let is_osx = self.tcx.sess.target.target.options.is_like_osx; if lib.kind == cstore::NativeFramework && !is_osx { let msg = "native frameworks are only available on macOS targets"; match span { Some(span) => span_err!(self.tcx.sess, span, E0455, "{}", msg), None => self.tcx.sess.err(msg), } } if lib.cfg.is_some() && !self.tcx.features().link_cfg { feature_gate::emit_feature_err(&self.tcx.sess.parse_sess, "link_cfg", span.unwrap(), GateIssue::Language, "is feature gated"); } if lib.kind == cstore::NativeStaticNobundle && !self.tcx.features().static_nobundle { feature_gate::emit_feature_err(&self.tcx.sess.parse_sess, "static_nobundle", span.unwrap(), GateIssue::Language, "kind=\"static-nobundle\" is feature gated"); } self.libs.push(lib); } // Process libs passed on the command line fn process_command_line(&mut self) { // First, check for errors let mut renames = FxHashSet(); for &(ref name, ref new_name, _) in &self.tcx.sess.opts.libs { if let &Some(ref new_name) = new_name { if new_name.is_empty() { self.tcx.sess.err( &format!("an empty renaming target was specified for library `{}`",name)); } else if !self.libs.iter().any(|lib| lib.name == name as &str) { self.tcx.sess.err(&format!("renaming of the library `{}` was specified, \ however this crate contains no #[link(...)] \ attributes referencing this library.", name)); } else if renames.contains(name) { self.tcx.sess.err(&format!("multiple renamings were \ specified for library `{}` .", name)); } else { renames.insert(name); } } } // Update kind and, optionally, the name of all native libaries // (there may be more than one) with the specified name. for &(ref name, ref new_name, kind) in &self.tcx.sess.opts.libs { let mut found = false; for lib in self.libs.iter_mut() { if lib.name == name as &str { let mut changed = false; if let Some(k) = kind { lib.kind = k; changed = true; } if let &Some(ref new_name) = new_name { lib.name = Symbol::intern(new_name); changed = true; } if !changed { let msg = format!("redundant linker flag specified for \ library `{}`", name); self.tcx.sess.warn(&msg); } found = true; } } if !found { // Add if not found let new_name = new_name.as_ref().map(|s| &**s); // &Option -> Option<&str> let lib = NativeLibrary { name: Symbol::intern(new_name.unwrap_or(name)), kind: if let Some(k) = kind { k } else { cstore::NativeUnknown }, cfg: None, foreign_module: None, }; self.register_native_lib(None, lib); } } } }