src/librustc/middle/weak_lang_items.rs

   1 // Copyright 2014 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.
   4 //
   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.
  10
  11 //! Validity checking for weak lang items
  12
  13 use session::config;
  14 use middle::lang_items;
  15
  16 use rustc_target::spec::PanicStrategy;
  17 use syntax::ast;
  18 use syntax::symbol::Symbol;
  19 use syntax_pos::Span;
  20 use hir::def_id::DefId;
  21 use hir::intravisit::{Visitor, NestedVisitorMap};
  22 use hir::intravisit;
  23 use hir;
  24 use ty::TyCtxt;
  25
  26 use std::collections::HashSet;
  27
  28 macro_rules! weak_lang_items {
  29     ($($name:ident, $item:ident, $sym:ident;)*) => (
  30
  31 struct Context<'a, 'tcx: 'a> {
  32     tcx: TyCtxt<'a, 'tcx, 'tcx>,
  33     items: &'a mut lang_items::LanguageItems,
  34 }
  35
  36 /// Checks the crate for usage of weak lang items, returning a vector of all the
  37 /// language items required by this crate, but not defined yet.
  38 pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
  39                              items: &mut lang_items::LanguageItems) {
  40     // These are never called by user code, they're generated by the compiler.
  41     // They will never implicitly be added to the `missing` array unless we do
  42     // so here.
  43     if items.eh_personality().is_none() {
  44         items.missing.push(lang_items::EhPersonalityLangItem);
  45     }
  46     if tcx.sess.target.target.options.custom_unwind_resume &
  47        items.eh_unwind_resume().is_none() {
  48         items.missing.push(lang_items::EhUnwindResumeLangItem);
  49     }
  50
  51     {
  52         let mut cx = Context { tcx, items };
  53         tcx.hir.krate().visit_all_item_likes(&mut cx.as_deep_visitor());
  54     }
  55     verify(tcx, items);
  56 }
  57
  58 pub fn link_name(attrs: &[ast::Attribute]) -> Option<Symbol> {
  59     lang_items::extract(attrs).and_then(|(name, _)| {
  60         $(if name == stringify!($name) {
  61             Some(Symbol::intern(stringify!($sym)))
  62         } else)* {
  63             None
  64         }
  65     })
  66 }
  67
  68 /// Returns whether the specified `lang_item` doesn't actually need to be
  69 /// present for this compilation.
  70 ///
  71 /// Not all lang items are always required for each compilation, particularly in
  72 /// the case of panic=abort. In these situations some lang items are injected by
  73 /// crates and don't actually need to be defined in libstd.
  74 pub fn whitelisted(tcx: TyCtxt, lang_item: lang_items::LangItem) -> bool {
  75     // If we're not compiling with unwinding, we won't actually need these
  76     // symbols. Other panic runtimes ensure that the relevant symbols are
  77     // available to link things together, but they're never exercised.
  78     if tcx.sess.panic_strategy() != PanicStrategy::Unwind {
  79         return lang_item == lang_items::EhPersonalityLangItem ||
  80             lang_item == lang_items::EhUnwindResumeLangItem
  81     }
  82
  83     false
  84 }
  85
  86 fn verify<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
  87                     items: &lang_items::LanguageItems) {
  88     // We only need to check for the presence of weak lang items if we're
  89     // emitting something that's not an rlib.
  90     let needs_check = tcx.sess.crate_types.borrow().iter().any(|kind| {
  91         match *kind {
  92             config::CrateType::Dylib |
  93             config::CrateType::ProcMacro |
  94             config::CrateType::Cdylib |
  95             config::CrateType::Executable |
  96             config::CrateType::Staticlib => true,
  97             config::CrateType::Rlib => false,
  98         }
  99     });
 100     if !needs_check {
 101         return
 102     }
 103
 104     let mut missing = HashSet::new();
 105     for &cnum in tcx.crates().iter() {
 106         for &item in tcx.missing_lang_items(cnum).iter() {
 107             missing.insert(item);
 108         }
 109     }
 110
 111     $(
 112         if missing.contains(&lang_items::$item) &&
 113            !whitelisted(tcx, lang_items::$item) &&
 114            items.$name().is_none() {
 115             if lang_items::$item == lang_items::PanicImplLangItem {
 116                 tcx.sess.err(&format!("`#[panic_implementation]` function required, \
 117                                         but not found"));
 118             } else if lang_items::$item == lang_items::OomLangItem {
 119                 tcx.sess.err(&format!("`#[alloc_error_handler]` function required, \
 120                                         but not found"));
 121             } else {
 122                 tcx.sess.err(&format!("language item required, but not found: `{}`",
 123                                         stringify!($name)));
 124             }
 125         }
 126     )*
 127 }
 128
 129 impl<'a, 'tcx> Context<'a, 'tcx> {
 130     fn register(&mut self, name: &str, span: Span) {
 131         $(if name == stringify!($name) {
 132             if self.items.$name().is_none() {
 133                 self.items.missing.push(lang_items::$item);
 134             }
 135         } else)* {
 136             span_err!(self.tcx.sess, span, E0264,
 137                       "unknown external lang item: `{}`",
 138                       name);
 139         }
 140     }
 141 }
 142
 143 impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
 144     fn nested_visit_map<'this>(&'this mut self) -> NestedVisitorMap<'this, 'v> {
 145         NestedVisitorMap::None
 146     }
 147
 148     fn visit_foreign_item(&mut self, i: &hir::ForeignItem) {
 149         if let Some((lang_item, _)) = lang_items::extract(&i.attrs) {
 150             self.register(&lang_item.as_str(), i.span);
 151         }
 152         intravisit::walk_foreign_item(self, i)
 153     }
 154 }
 155
 156 impl<'a, 'tcx, 'gcx> TyCtxt<'a, 'tcx, 'gcx> {
 157     pub fn is_weak_lang_item(&self, item_def_id: DefId) -> bool {
 158         let lang_items = self.lang_items();
 159         let did = Some(item_def_id);
 160
 161         $(lang_items.$name() == did)||+
 162     }
 163 }
 164
 165 ) }
 166
 167 weak_lang_items! {
 168     panic_impl,         PanicImplLangItem,          rust_begin_unwind;
 169     eh_personality,     EhPersonalityLangItem,      rust_eh_personality;
 170     eh_unwind_resume,   EhUnwindResumeLangItem,     rust_eh_unwind_resume;
 171     oom,                OomLangItem,                rust_oom;
 172 }