Support weak/common/private/etc. symbol linkage.

This commit adds a feature-gated #[linkage = "foo"] attribute that can
be applied to extern functions and instructs the linker on how to
resolve the symbol.

"extern_weak" linkage is the most immediately useful one because it
lets us link to library symbols that may or may not exist at run-time.

Note that non-default linkage types require toolchain and (sometimes)
dynamic linker support.  For example, "extern_weak" is accepted but
not actually supported by OS X's dyld.

I decided not to warn for known bad platform/linkage combinations
because clang and gcc don't do so either and because you don't rightly
know whether the user is actually using the problematic toolchain or
dynamic linker.  For all we know, they're implementing their own ELF
loader.

Author: bnoordhuis

src/librustc/front/feature_gate.rs

@@ -43,6 +43,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("non_ascii_idents", Active),
     ("thread_local", Active),
     ("link_args", Active),
+    ("linkage", Active),
     ("phase", Active),
     ("macro_registrar", Active),
     ("log_syntax", Active),
@@ -188,6 +189,18 @@ impl Visitor<()> for Context {
         visit::walk_item(self, i, ());
     }
 
+    fn visit_foreign_item(&mut self, i: &ast::ForeignItem, _: ()) {
+        match i.node {
+            ast::ForeignItemFn(..) | ast::ForeignItemStatic(..) => {
+                if attr::contains_name(i.attrs, "linkage") {
+                    self.gate_feature("linkage", i.span,
+                                      "the `linkage` attribute is experimental \
+                                       and not portable across platforms")
+                }
+            },
+        }
+    }
+
     fn visit_mac(&mut self, macro: &ast::Mac, _: ()) {
         let ast::MacInvocTT(ref path, _, _) = macro.node;
         let id = path.segments.last().unwrap().identifier;

src/librustc/middle/lint.rs

@@ -974,7 +974,7 @@ static other_attrs: &'static [&'static str] = &[
 
     // fn-level
     "test", "bench", "should_fail", "ignore", "inline", "lang", "main", "start",
-    "no_split_stack", "cold", "macro_registrar",
+    "no_split_stack", "cold", "macro_registrar", "linkage",
 
     // internal attribute: bypass privacy inside items
     "!resolve_unexported",

src/librustc/middle/trans/foreign.rs

@@ -11,7 +11,7 @@
 
 use back::{link};
 use lib::llvm::llvm;
-use lib::llvm::{ValueRef, CallConv, StructRetAttribute};
+use lib::llvm::{ValueRef, CallConv, Linkage, StructRetAttribute};
 use lib;
 use middle::trans::base::push_ctxt;
 use middle::trans::base;
@@ -106,6 +106,34 @@ pub fn llvm_calling_convention(ccx: &CrateContext,
 }
 
 
+pub fn llvm_linkage_by_name(name: &str) -> Option<Linkage> {
+    // Use the names from src/llvm/docs/LangRef.rst here.  Most types are only
+    // applicable to variable declarations and may not really make sense for
+    // Rust code in the first place but whitelist them anyway and trust that
+    // the user knows what s/he's doing.  Who knows, unanticipated use cases
+    // may pop up in the future.
+    //
+    // ghost, dllimport, dllexport and linkonce_odr_autohide are not supported
+    // and don't have to be, LLVM treats them as no-ops.
+    match name {
+        "appending" => Some(lib::llvm::AppendingLinkage),
+        "available_externally" => Some(lib::llvm::AvailableExternallyLinkage),
+        "common" => Some(lib::llvm::CommonLinkage),
+        "extern_weak" => Some(lib::llvm::ExternalWeakLinkage),
+        "external" => Some(lib::llvm::ExternalLinkage),
+        "internal" => Some(lib::llvm::InternalLinkage),
+        "linker_private" => Some(lib::llvm::LinkerPrivateLinkage),
+        "linker_private_weak" => Some(lib::llvm::LinkerPrivateWeakLinkage),
+        "linkonce" => Some(lib::llvm::LinkOnceAnyLinkage),
+        "linkonce_odr" => Some(lib::llvm::LinkOnceODRLinkage),
+        "private" => Some(lib::llvm::PrivateLinkage),
+        "weak" => Some(lib::llvm::WeakAnyLinkage),
+        "weak_odr" => Some(lib::llvm::WeakODRLinkage),
+        _ => None,
+    }
+}
+
+
 pub fn register_foreign_item_fn(ccx: @CrateContext,
                                 abis: AbiSet,
                                 path: &ast_map::Path,
@@ -158,6 +186,18 @@ pub fn register_foreign_item_fn(ccx: @CrateContext,
                                    llfn_ty,
                                    tys.fn_sig.output);
     };
+
+    match attr::first_attr_value_str_by_name(foreign_item.attrs, "linkage") {
+        Some(name) => {
+            match llvm_linkage_by_name(name.get()) {
+                Some(linkage) => lib::llvm::SetLinkage(llfn, linkage),
+                None => ccx.sess.span_fatal(foreign_item.span,
+                                            format!("Bad linkage `{}`", name)),
+            }
+        },
+        None => {},  // Default "external" linkage.
+    }
+
     add_argument_attributes(&tys, llfn);
 
     return llfn;

src/test/run-pass/linkage.rs

@@ -0,0 +1,43 @@
+// Copyright 2014 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[feature(linkage)];
+
+use std::cast;
+use std::ptr;
+
+fn external() {
+    extern {
+        #[linkage = "external"]
+        fn abort();
+    }
+    let ptr: *u8 = unsafe { cast::transmute(abort) };
+    assert!(ptr != ptr::null());
+}
+
+#[cfg(target_os = "linux")]
+fn extern_weak() {
+    extern {
+        #[linkage = "extern_weak"]
+        fn frobnitz();
+    }
+    let ptr: *u8 = unsafe { cast::transmute(frobnitz) };
+    assert!(ptr == ptr::null());
+}
+
+#[cfg(not(target_os = "linux"))]
+fn extern_weak() {
+    // Not supported.
+}
+
+fn main() {
+    external();
+    extern_weak();
+}