auto merge of #14293 : alexcrichton/rust/weak-lang-items, r=brson

This commit is part of the ongoing libstd facade efforts (cc #13851). The
compiler now recognizes some language items as "extern { fn foo(...); }" and
will automatically perform the following actions:

1. The foreign function has a pre-defined name.
2. The crate and downstream crates can only be built as rlibs until a crate
   defines the lang item itself.
3. The actual lang item has a pre-defined name.

This is essentially nicer compiler support for the hokey
core-depends-on-std-failure scheme today, but it is implemented the same way.
The details are a little more hidden under the covers.

In addition to failure, this commit promotes the eh_personality and
rust_stack_exhausted functions to official lang items. The compiler can generate
calls to these functions, causing linkage errors if they are left undefined. The
checking for these items is not as precise as it could be. Crates compiling with
`-Z no-landing-pads` will not need the eh_personality lang item, and crates
compiling with no split stacks won't need the stack exhausted lang item. For
ease, however, these items are checked for presence in all final outputs of the
compiler.

It is quite easy to define dummy versions of the functions necessary:

    #[lang = "stack_exhausted"]
    extern fn stack_exhausted() { /* ... */ }

    #[lang = "eh_personality"]
    extern fn eh_personality() { /* ... */ }

cc #11922, rust_stack_exhausted is now a lang item
cc #13851, libcollections is blocked on eh_personality becoming weak

Author: bors

src/libcore/failure.rs

@@ -60,10 +60,19 @@ fn fail_bounds_check(file: *u8, line: uint, index: uint, len: uint) -> ! {
 
 #[cold]
 pub fn begin_unwind(fmt: &fmt::Arguments, file: &'static str, line: uint) -> ! {
-    // FIXME: this should be a proper lang item, it should not just be some
-    //        undefined symbol sitting in the middle of nowhere.
     #[allow(ctypes)]
-    extern { fn rust_begin_unwind(fmt: &fmt::Arguments, file: &'static str,
-                                  line: uint) -> !; }
-    unsafe { rust_begin_unwind(fmt, file, line) }
+    #[cfg(stage0)]
+    extern {
+        #[link_name = "rust_begin_unwind"]
+        fn begin_unwind(fmt: &fmt::Arguments, file: &'static str,
+                        line: uint) -> !;
+    }
+    #[allow(ctypes)]
+    #[cfg(not(stage0))]
+    extern {
+        #[lang = "begin_unwind"]
+        fn begin_unwind(fmt: &fmt::Arguments, file: &'static str,
+                        line: uint) -> !;
+    }
+    unsafe { begin_unwind(fmt, file, line) }
 }

src/librustc/lib.rs

@@ -78,6 +78,7 @@ pub mod middle {
     pub mod dead;
     pub mod expr_use_visitor;
     pub mod dependency_format;
+    pub mod weak_lang_items;
 }
 
 pub mod front {

src/librustc/metadata/common.rs

@@ -167,8 +167,9 @@ pub static tag_lang_items: uint = 0x70;
 pub static tag_lang_items_item: uint = 0x71;
 pub static tag_lang_items_item_id: uint = 0x72;
 pub static tag_lang_items_item_node_id: uint = 0x73;
+pub static tag_lang_items_missing: uint = 0x74;
 
-pub static tag_item_unnamed_field: uint = 0x74;
+pub static tag_item_unnamed_field: uint = 0x75;
 pub static tag_items_data_item_visibility: uint = 0x76;
 pub static tag_items_data_item_sized: uint = 0x77;
 

src/librustc/metadata/csearch.rs

@@ -15,6 +15,7 @@
 use metadata::common::*;
 use metadata::cstore;
 use metadata::decoder;
+use middle::lang_items;
 use middle::ty;
 use middle::typeck;
 
@@ -298,3 +299,10 @@ pub fn get_dylib_dependency_formats(cstore: &cstore::CStore,
     let cdata = cstore.get_crate_data(cnum);
     decoder::get_dylib_dependency_formats(&*cdata)
 }
+
+pub fn get_missing_lang_items(cstore: &cstore::CStore, cnum: ast::CrateNum)
+    -> Vec<lang_items::LangItem>
+{
+    let cdata = cstore.get_crate_data(cnum);
+    decoder::get_missing_lang_items(&*cdata)
+}

src/librustc/metadata/decoder.rs

@@ -21,6 +21,7 @@ use metadata::cstore;
 use metadata::tydecode::{parse_ty_data, parse_def_id,
                          parse_type_param_def_data,
                          parse_bare_fn_ty_data, parse_trait_ref_data};
+use middle::lang_items;
 use middle::ty::{ImplContainer, TraitContainer};
 use middle::ty;
 use middle::typeck;
@@ -1299,3 +1300,17 @@ pub fn get_dylib_dependency_formats(cdata: Cmd)
     }
     return result;
 }
+
+pub fn get_missing_lang_items(cdata: Cmd)
+    -> Vec<lang_items::LangItem>
+{
+    let items = reader::get_doc(reader::Doc(cdata.data()), tag_lang_items);
+    let mut result = Vec::new();
+    reader::tagged_docs(items, tag_lang_items_missing, |missing_doc| {
+        let item: lang_items::LangItem =
+            FromPrimitive::from_u32(reader::doc_as_u32(missing_doc)).unwrap();
+        result.push(item);
+        true
+    });
+    return result;
+}

src/librustc/metadata/encoder.rs

@@ -1518,6 +1518,10 @@ fn encode_lang_items(ecx: &EncodeContext, ebml_w: &mut Encoder) {
         }
     }
 
+    for i in ecx.tcx.lang_items.missing.iter() {
+        ebml_w.wr_tagged_u32(tag_lang_items_missing, *i as u32);
+    }
+
     ebml_w.end_tag();   // tag_lang_items
 }
 

src/librustc/middle/lang_items.rs

@@ -23,6 +23,7 @@
 use driver::session::Session;
 use metadata::csearch::each_lang_item;
 use middle::ty;
+use middle::weak_lang_items;
 use syntax::ast;
 use syntax::ast_util::local_def;
 use syntax::attr::AttrMetaMethods;
@@ -41,21 +42,23 @@ macro_rules! lets_do_this {
         $( $variant:ident, $name:expr, $method:ident; )*
     ) => {
 
-#[deriving(FromPrimitive)]
+#[deriving(FromPrimitive, Eq, TotalEq, Hash)]
 pub enum LangItem {
     $($variant),*
 }
 
 pub struct LanguageItems {
-    pub items: Vec<Option<ast::DefId>> ,
+    pub items: Vec<Option<ast::DefId>>,
+    pub missing: Vec<LangItem>,
 }
 
 impl LanguageItems {
     pub fn new() -> LanguageItems {
         fn foo(_: LangItem) -> Option<ast::DefId> { None }
 
         LanguageItems {
-            items: vec!($(foo($variant)),*)
+            items: vec!($(foo($variant)),*),
+            missing: Vec::new(),
         }
     }
 
@@ -198,7 +201,8 @@ pub fn collect_language_items(krate: &ast::Crate,
                               session: &Session) -> LanguageItems {
     let mut collector = LanguageItemCollector::new(session);
     collector.collect(krate);
-    let LanguageItemCollector { items, .. } = collector;
+    let LanguageItemCollector { mut items, .. } = collector;
+    weak_lang_items::check_crate(krate, session, &mut items);
     session.abort_if_errors();
     items
 }
@@ -240,8 +244,20 @@ lets_do_this! {
 
     StrEqFnLangItem,                 "str_eq",                  str_eq_fn;
     UniqStrEqFnLangItem,             "uniq_str_eq",             uniq_str_eq_fn;
+
+    // A number of failure-related lang items. The `fail_` item corresponds to
+    // divide-by-zero and various failure cases with `match`. The
+    // `fail_bounds_check` item is for indexing arrays.
+    //
+    // The `begin_unwind` lang item has a predefined symbol name and is sort of
+    // a "weak lang item" in the sense that a crate is not required to have it
+    // defined to use it, but a final product is required to define it
+    // somewhere. Additionally, there are restrictions on crates that use a weak
+    // lang item, but do not have it defined.
     FailFnLangItem,                  "fail_",                   fail_fn;
     FailBoundsCheckFnLangItem,       "fail_bounds_check",       fail_bounds_check_fn;
+    BeginUnwindLangItem,             "begin_unwind",            begin_unwind;
+
     ExchangeMallocFnLangItem,        "exchange_malloc",         exchange_malloc_fn;
     ClosureExchangeMallocFnLangItem, "closure_exchange_malloc", closure_exchange_malloc_fn;
     ExchangeFreeFnLangItem,          "exchange_free",           exchange_free_fn;
@@ -257,7 +273,7 @@ lets_do_this! {
 
     TypeIdLangItem,                  "type_id",                 type_id;
 
-    EhPersonalityLangItem,           "eh_personality",          eh_personality_fn;
+    EhPersonalityLangItem,           "eh_personality",          eh_personality;
 
     ManagedHeapLangItem,             "managed_heap",            managed_heap;
     ExchangeHeapLangItem,            "exchange_heap",           exchange_heap;
@@ -276,4 +292,6 @@ lets_do_this! {
     NoCopyItem,                      "no_copy_bound",           no_copy_bound;
     NoShareItem,                     "no_share_bound",          no_share_bound;
     ManagedItem,                     "managed_bound",           managed_bound;
+
+    StackExhaustedLangItem,          "stack_exhausted",         stack_exhausted;
 }

src/librustc/middle/trans/base.rs

@@ -38,6 +38,7 @@ use lib;
 use metadata::{csearch, encoder};
 use middle::astencode;
 use middle::lang_items::{LangItem, ExchangeMallocFnLangItem, StartFnLangItem};
+use middle::weak_lang_items;
 use middle::trans::_match;
 use middle::trans::adt;
 use middle::trans::build::*;
@@ -1679,6 +1680,19 @@ fn finish_register_fn(ccx: &CrateContext, sp: Span, sym: StrBuf, node_id: ast::N
         lib::llvm::SetLinkage(llfn, lib::llvm::InternalLinkage);
     }
 
+    // The stack exhaustion lang item shouldn't have a split stack because
+    // otherwise it would continue to be exhausted (bad), and both it and the
+    // eh_personality functions need to be externally linkable.
+    let def = ast_util::local_def(node_id);
+    if ccx.tcx.lang_items.stack_exhausted() == Some(def) {
+        unset_split_stack(llfn);
+        lib::llvm::SetLinkage(llfn, lib::llvm::ExternalLinkage);
+    }
+    if ccx.tcx.lang_items.eh_personality() == Some(def) {
+        lib::llvm::SetLinkage(llfn, lib::llvm::ExternalLinkage);
+    }
+
+
     if is_entry_fn(ccx.sess(), node_id) {
         create_entry_wrapper(ccx, sp, llfn);
     }
@@ -1816,8 +1830,13 @@ fn exported_name(ccx: &CrateContext, id: ast::NodeId,
                 // Don't mangle
                 path.last().unwrap().to_str().to_strbuf()
             } else {
-                // Usual name mangling
-                mangle_exported_name(ccx, path, ty, id)
+                match weak_lang_items::link_name(attrs) {
+                    Some(name) => name.get().to_strbuf(),
+                    None => {
+                        // Usual name mangling
+                        mangle_exported_name(ccx, path, ty, id)
+                    }
+                }
             }
         })
     }

src/librustc/middle/trans/cleanup.rs

@@ -14,7 +14,6 @@
  */
 
 use lib::llvm::{BasicBlockRef, ValueRef};
-use middle::lang_items::{EhPersonalityLangItem};
 use middle::trans::base;
 use middle::trans::build;
 use middle::trans::callee;
@@ -665,8 +664,31 @@ impl<'a> CleanupHelperMethods<'a> for FunctionContext<'a> {
                                     false);
 
         // The exception handling personality function.
-        let def_id = common::langcall(pad_bcx, None, "", EhPersonalityLangItem);
-        let llpersonality = callee::trans_fn_ref(pad_bcx, def_id, ExprId(0));
+        //
+        // If our compilation unit has the `eh_personality` lang item somewhere
+        // within it, then we just need to translate that. Otherwise, we're
+        // building an rlib which will depend on some upstream implementation of
+        // this function, so we just codegen a generic reference to it. We don't
+        // specify any of the types for the function, we just make it a symbol
+        // that LLVM can later use.
+        let llpersonality = match pad_bcx.tcx().lang_items.eh_personality() {
+            Some(def_id) => callee::trans_fn_ref(pad_bcx, def_id, ExprId(0)),
+            None => {
+                let mut personality = self.ccx.eh_personality.borrow_mut();
+                match *personality {
+                    Some(llpersonality) => llpersonality,
+                    None => {
+                        let fty = Type::variadic_func(&[], &Type::i32(self.ccx));
+                        let f = base::decl_cdecl_fn(self.ccx.llmod,
+                                                    "rust_eh_personality",
+                                                    fty,
+                                                    ty::mk_i32());
+                        *personality = Some(f);
+                        f
+                    }
+                }
+            }
+        };
 
         // The only landing pad clause will be 'cleanup'
         let llretval = build::LandingPad(pad_bcx, llretty, llpersonality, 1u);

src/librustc/middle/trans/context.rs

@@ -122,6 +122,8 @@ pub struct CrateContext {
     pub uses_gc: bool,
     pub dbg_cx: Option<debuginfo::CrateDebugContext>,
 
+    pub eh_personality: RefCell<Option<ValueRef>>,
+
     intrinsics: RefCell<HashMap<&'static str, ValueRef>>,
 }
 
@@ -224,6 +226,7 @@ impl CrateContext {
                 builder: BuilderRef_res(llvm::LLVMCreateBuilderInContext(llcx)),
                 uses_gc: false,
                 dbg_cx: dbg_cx,
+                eh_personality: RefCell::new(None),
                 intrinsics: RefCell::new(HashMap::new()),
             };
 

src/librustc/middle/trans/foreign.rs

@@ -13,6 +13,7 @@ use back::{link};
 use lib::llvm::llvm;
 use lib::llvm::{ValueRef, CallConv, StructRetAttribute, Linkage};
 use lib;
+use middle::weak_lang_items;
 use middle::trans::base::push_ctxt;
 use middle::trans::base;
 use middle::trans::build::*;
@@ -815,10 +816,12 @@ pub fn trans_rust_fn_with_foreign_abi(ccx: &CrateContext,
 // the massive simplifications that have occurred.
 
 pub fn link_name(i: &ast::ForeignItem) -> InternedString {
-     match attr::first_attr_value_str_by_name(i.attrs.as_slice(),
-                                              "link_name") {
-        None => token::get_ident(i.ident),
+    match attr::first_attr_value_str_by_name(i.attrs.as_slice(), "link_name") {
         Some(ln) => ln.clone(),
+        None => match weak_lang_items::link_name(i.attrs.as_slice()) {
+            Some(name) => name,
+            None => token::get_ident(i.ident),
+        }
     }
 }