compiler/rustc_metadata/src/native_libs.rs

   1 use rustc_attr as attr;
   2 use rustc_data_structures::fx::FxHashSet;
   3 use rustc_errors::struct_span_err;
   4 use rustc_hir as hir;
   5 use rustc_hir::itemlikevisit::ItemLikeVisitor;
   6 use rustc_middle::middle::cstore::NativeLib;
   7 use rustc_middle::ty::TyCtxt;
   8 use rustc_session::parse::feature_err;
   9 use rustc_session::utils::NativeLibKind;
  10 use rustc_session::Session;
  11 use rustc_span::source_map::Span;
  12 use rustc_span::symbol::{kw, sym, Symbol};
  13 use rustc_target::spec::abi::Abi;
  14
  15 crate fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLib> {
  16     let mut collector = Collector { tcx, libs: Vec::new() };
  17     tcx.hir().krate().visit_all_item_likes(&mut collector);
  18     collector.process_command_line();
  19     collector.libs
  20 }
  21
  22 crate fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {
  23     match lib.cfg {
  24         Some(ref cfg) => attr::cfg_matches(cfg, &sess.parse_sess, None),
  25         None => true,
  26     }
  27 }
  28
  29 struct Collector<'tcx> {
  30     tcx: TyCtxt<'tcx>,
  31     libs: Vec<NativeLib>,
  32 }
  33
  34 impl ItemLikeVisitor<'tcx> for Collector<'tcx> {
  35     fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) {
  36         let abi = match it.kind {
  37             hir::ItemKind::ForeignMod { abi, .. } => abi,
  38             _ => return,
  39         };
  40
  41         if abi == Abi::Rust || abi == Abi::RustIntrinsic || abi == Abi::PlatformIntrinsic {
  42             return;
  43         }
  44
  45         // Process all of the #[link(..)]-style arguments
  46         let sess = &self.tcx.sess;
  47         for m in self.tcx.hir().attrs(it.hir_id()).iter().filter(|a| sess.check_name(a, sym::link))
  48         {
  49             let items = match m.meta_item_list() {
  50                 Some(item) => item,
  51                 None => continue,
  52             };
  53             let mut lib = NativeLib {
  54                 name: None,
  55                 kind: NativeLibKind::Unspecified,
  56                 cfg: None,
  57                 foreign_module: Some(it.def_id.to_def_id()),
  58                 wasm_import_module: None,
  59             };
  60             let mut kind_specified = false;
  61
  62             for item in items.iter() {
  63                 if item.has_name(sym::kind) {
  64                     kind_specified = true;
  65                     let kind = match item.value_str() {
  66                         Some(name) => name,
  67                         None => continue, // skip like historical compilers
  68                     };
  69                     lib.kind = match &*kind.as_str() {
  70                         "static" => NativeLibKind::StaticBundle,
  71                         "static-nobundle" => NativeLibKind::StaticNoBundle,
  72                         "dylib" => NativeLibKind::Dylib,
  73                         "framework" => NativeLibKind::Framework,
  74                         "raw-dylib" => NativeLibKind::RawDylib,
  75                         k => {
  76                             struct_span_err!(sess, item.span(), E0458, "unknown kind: `{}`", k)
  77                                 .span_label(item.span(), "unknown kind")
  78                                 .span_label(m.span, "")
  79                                 .emit();
  80                             NativeLibKind::Unspecified
  81                         }
  82                     };
  83                 } else if item.has_name(sym::name) {
  84                     lib.name = item.value_str();
  85                 } else if item.has_name(sym::cfg) {
  86                     let cfg = match item.meta_item_list() {
  87                         Some(list) => list,
  88                         None => continue, // skip like historical compilers
  89                     };
  90                     if cfg.is_empty() {
  91                         sess.span_err(item.span(), "`cfg()` must have an argument");
  92                     } else if let cfg @ Some(..) = cfg[0].meta_item() {
  93                         lib.cfg = cfg.cloned();
  94                     } else {
  95                         sess.span_err(cfg[0].span(), "invalid argument for `cfg(..)`");
  96                     }
  97                 } else if item.has_name(sym::wasm_import_module) {
  98                     match item.value_str() {
  99                         Some(s) => lib.wasm_import_module = Some(s),
 100                         None => {
 101                             let msg = "must be of the form `#[link(wasm_import_module = \"...\")]`";
 102                             sess.span_err(item.span(), msg);
 103                         }
 104                     }
 105                 } else {
 106                     // currently, like past compilers, ignore unknown
 107                     // directives here.
 108                 }
 109             }
 110
 111             // In general we require #[link(name = "...")] but we allow
 112             // #[link(wasm_import_module = "...")] without the `name`.
 113             let requires_name = kind_specified || lib.wasm_import_module.is_none();
 114             if lib.name.is_none() && requires_name {
 115                 struct_span_err!(
 116                     sess,
 117                     m.span,
 118                     E0459,
 119                     "`#[link(...)]` specified without \
 120                                   `name = \"foo\"`"
 121                 )
 122                 .span_label(m.span, "missing `name` argument")
 123                 .emit();
 124             }
 125             self.register_native_lib(Some(m.span), lib);
 126         }
 127     }
 128
 129     fn visit_trait_item(&mut self, _it: &'tcx hir::TraitItem<'tcx>) {}
 130     fn visit_impl_item(&mut self, _it: &'tcx hir::ImplItem<'tcx>) {}
 131     fn visit_foreign_item(&mut self, _it: &'tcx hir::ForeignItem<'tcx>) {}
 132 }
 133
 134 impl Collector<'tcx> {
 135     fn register_native_lib(&mut self, span: Option<Span>, lib: NativeLib) {
 136         if lib.name.as_ref().map_or(false, |&s| s == kw::Empty) {
 137             match span {
 138                 Some(span) => {
 139                     struct_span_err!(
 140                         self.tcx.sess,
 141                         span,
 142                         E0454,
 143                         "`#[link(name = \"\")]` given with empty name"
 144                     )
 145                     .span_label(span, "empty name given")
 146                     .emit();
 147                 }
 148                 None => {
 149                     self.tcx.sess.err("empty library name given via `-l`");
 150                 }
 151             }
 152             return;
 153         }
 154         let is_osx = self.tcx.sess.target.is_like_osx;
 155         if lib.kind == NativeLibKind::Framework && !is_osx {
 156             let msg = "native frameworks are only available on macOS targets";
 157             match span {
 158                 Some(span) => struct_span_err!(self.tcx.sess, span, E0455, "{}", msg).emit(),
 159                 None => self.tcx.sess.err(msg),
 160             }
 161         }
 162         if lib.cfg.is_some() && !self.tcx.features().link_cfg {
 163             feature_err(
 164                 &self.tcx.sess.parse_sess,
 165                 sym::link_cfg,
 166                 span.unwrap(),
 167                 "kind=\"link_cfg\" is unstable",
 168             )
 169             .emit();
 170         }
 171         if lib.kind == NativeLibKind::StaticNoBundle && !self.tcx.features().static_nobundle {
 172             feature_err(
 173                 &self.tcx.sess.parse_sess,
 174                 sym::static_nobundle,
 175                 span.unwrap_or(rustc_span::DUMMY_SP),
 176                 "kind=\"static-nobundle\" is unstable",
 177             )
 178             .emit();
 179         }
 180         if lib.kind == NativeLibKind::RawDylib && !self.tcx.features().raw_dylib {
 181             feature_err(
 182                 &self.tcx.sess.parse_sess,
 183                 sym::raw_dylib,
 184                 span.unwrap_or(rustc_span::DUMMY_SP),
 185                 "kind=\"raw-dylib\" is unstable",
 186             )
 187             .emit();
 188         }
 189         self.libs.push(lib);
 190     }
 191
 192     // Process libs passed on the command line
 193     fn process_command_line(&mut self) {
 194         // First, check for errors
 195         let mut renames = FxHashSet::default();
 196         for (name, new_name, _) in &self.tcx.sess.opts.libs {
 197             if let Some(ref new_name) = new_name {
 198                 let any_duplicate = self
 199                     .libs
 200                     .iter()
 201                     .filter_map(|lib| lib.name.as_ref())
 202                     .any(|n| &n.as_str() == name);
 203                 if new_name.is_empty() {
 204                     self.tcx.sess.err(&format!(
 205                         "an empty renaming target was specified for library `{}`",
 206                         name
 207                     ));
 208                 } else if !any_duplicate {
 209                     self.tcx.sess.err(&format!(
 210                         "renaming of the library `{}` was specified, \
 211                                                 however this crate contains no `#[link(...)]` \
 212                                                 attributes referencing this library.",
 213                         name
 214                     ));
 215                 } else if !renames.insert(name) {
 216                     self.tcx.sess.err(&format!(
 217                         "multiple renamings were \
 218                                                 specified for library `{}` .",
 219                         name
 220                     ));
 221                 }
 222             }
 223         }
 224
 225         // Update kind and, optionally, the name of all native libraries
 226         // (there may be more than one) with the specified name.  If any
 227         // library is mentioned more than once, keep the latest mention
 228         // of it, so that any possible dependent libraries appear before
 229         // it.  (This ensures that the linker is able to see symbols from
 230         // all possible dependent libraries before linking in the library
 231         // in question.)
 232         for &(ref name, ref new_name, kind) in &self.tcx.sess.opts.libs {
 233             // If we've already added any native libraries with the same
 234             // name, they will be pulled out into `existing`, so that we
 235             // can move them to the end of the list below.
 236             let mut existing = self
 237                 .libs
 238                 .drain_filter(|lib| {
 239                     if let Some(lib_name) = lib.name {
 240                         if lib_name.as_str() == *name {
 241                             if kind != NativeLibKind::Unspecified {
 242                                 lib.kind = kind;
 243                             }
 244                             if let Some(new_name) = new_name {
 245                                 lib.name = Some(Symbol::intern(new_name));
 246                             }
 247                             return true;
 248                         }
 249                     }
 250                     false
 251                 })
 252                 .collect::<Vec<_>>();
 253             if existing.is_empty() {
 254                 // Add if not found
 255                 let new_name = new_name.as_ref().map(|s| &**s); // &Option<String> -> Option<&str>
 256                 let lib = NativeLib {
 257                     name: Some(Symbol::intern(new_name.unwrap_or(name))),
 258                     kind,
 259                     cfg: None,
 260                     foreign_module: None,
 261                     wasm_import_module: None,
 262                 };
 263                 self.register_native_lib(None, lib);
 264             } else {
 265                 // Move all existing libraries with the same name to the
 266                 // end of the command line.
 267                 self.libs.append(&mut existing);
 268             }
 269         }
 270     }
 271 }