---

yaml
---
r: 108942
b: refs/heads/dist-snap
c: 9e0cfa2
h: refs/heads/master
v: v3

Author: zslayton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: f64fdf524a434f0e5cd0bc91d09c144723f3c90d
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 9f3ebd8fc50682d6e4ef549cb31e70171acdcd71
+refs/heads/dist-snap: 9e0cfa23e8b3d2d17302eefd9d728e63e7c6c108
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/librustc/front/feature_gate.rs

@@ -53,7 +53,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("simd", Active),
     ("default_type_params", Active),
     ("quote", Active),
-    ("linkage", Active),
 
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
@@ -239,19 +238,6 @@ impl Visitor<()> for Context {
         }
     }
 
-    fn visit_foreign_item(&mut self, i: &ast::ForeignItem, _: ()) {
-        match i.node {
-            ast::ForeignItemFn(..) | ast::ForeignItemStatic(..) => {
-                if attr::contains_name(i.attrs.as_slice(), "linkage") {
-                    self.gate_feature("linkage", i.span,
-                                      "the `linkage` attribute is experimental \
-                                       and not portable across platforms")
-                }
-            }
-        }
-        visit::walk_foreign_item(self, i, ())
-    }
-
     fn visit_ty(&mut self, t: &ast::Ty, _: ()) {
         match t.node {
             ast::TyClosure(closure) if closure.onceness == ast::Once &&

branches/dist-snap/src/librustc/middle/lint.rs

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

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -2107,6 +2107,7 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::NodeId) -> ValueRef {
                 }
 
                 ast_map::NodeForeignItem(ni) => {
+                    let ty = ty::node_id_to_type(ccx.tcx, ni.id);
                     foreign = true;
 
                     match ni.node {
@@ -2115,7 +2116,41 @@ pub fn get_item_val(ccx: @CrateContext, id: ast::NodeId) -> ValueRef {
                             foreign::register_foreign_item_fn(ccx, abis, ni)
                         }
                         ast::ForeignItemStatic(..) => {
-                            foreign::register_static(ccx, ni)
+                            // Treat the crate map static specially in order to
+                            // a weak-linkage-like functionality where it's
+                            // dynamically resolved at runtime. If we're
+                            // building a library, then we declare the static
+                            // with weak linkage, but if we're building a
+                            // library then we've already declared the crate map
+                            // so use that instead.
+                            if attr::contains_name(ni.attrs.as_slice(),
+                                                   "crate_map") {
+                                if ccx.sess.building_library.get() {
+                                    let s = "_rust_crate_map_toplevel";
+                                    let g = unsafe {
+                                        s.with_c_str(|buf| {
+                                            let ty = type_of(ccx, ty);
+                                            llvm::LLVMAddGlobal(ccx.llmod,
+                                                                ty.to_ref(),
+                                                                buf)
+                                        })
+                                    };
+                                    lib::llvm::SetLinkage(g,
+                                        lib::llvm::ExternalWeakLinkage);
+                                    g
+                                } else {
+                                    ccx.crate_map
+                                }
+                            } else {
+                                let ident = foreign::link_name(ni);
+                                unsafe {
+                                    ident.get().with_c_str(|buf| {
+                                        let ty = type_of(ccx, ty);
+                                        llvm::LLVMAddGlobal(ccx.llmod,
+                                                            ty.to_ref(), buf)
+                                    })
+                                }
+                            }
                         }
                     }
                 }

branches/dist-snap/src/librustc/middle/trans/foreign.rs

@@ -11,7 +11,7 @@
 
 use back::{link};
 use lib::llvm::llvm;
-use lib::llvm::{ValueRef, CallConv, StructRetAttribute, Linkage};
+use lib::llvm::{ValueRef, CallConv, StructRetAttribute};
 use lib;
 use middle::trans::base::push_ctxt;
 use middle::trans::base;
@@ -105,105 +105,6 @@ 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_static(ccx: @CrateContext,
-                       foreign_item: @ast::ForeignItem) -> ValueRef {
-    let ty = ty::node_id_to_type(ccx.tcx, foreign_item.id);
-    let llty = type_of::type_of(ccx, ty);
-
-    // Treat the crate map static specially in order to
-    // a weak-linkage-like functionality where it's
-    // dynamically resolved at runtime. If we're
-    // building a library, then we declare the static
-    // with weak linkage, but if we're building a
-    // library then we've already declared the crate map
-    // so use that instead.
-    if attr::contains_name(foreign_item.attrs.as_slice(), "crate_map") {
-        return if ccx.sess.building_library.get() {
-            let s = "_rust_crate_map_toplevel";
-            let g = unsafe {
-                s.with_c_str(|buf| {
-                    llvm::LLVMAddGlobal(ccx.llmod, llty.to_ref(), buf)
-                })
-            };
-            lib::llvm::SetLinkage(g, lib::llvm::ExternalWeakLinkage);
-            g
-        } else {
-            ccx.crate_map
-        }
-    }
-
-    let ident = link_name(foreign_item);
-    match attr::first_attr_value_str_by_name(foreign_item.attrs.as_slice(),
-                                             "linkage") {
-        // If this is a static with a linkage specified, then we need to handle
-        // it a little specially. The typesystem prevents things like &T and
-        // extern "C" fn() from being non-null, so we can't just declare a
-        // static and call it a day. Some linkages (like weak) will make it such
-        // that the static actually has a null value.
-        Some(name) => {
-            let linkage = match llvm_linkage_by_name(name.get()) {
-                Some(linkage) => linkage,
-                None => {
-                    ccx.sess.span_fatal(foreign_item.span,
-                                        "invalid linkage specified");
-                }
-            };
-            let llty2 = match ty::get(ty).sty {
-                ty::ty_ptr(ref mt) => type_of::type_of(ccx, mt.ty),
-                _ => {
-                    ccx.sess.span_fatal(foreign_item.span,
-                                        "must have type `*T` or `*mut T`");
-                }
-            };
-            unsafe {
-                let g1 = ident.get().with_c_str(|buf| {
-                    llvm::LLVMAddGlobal(ccx.llmod, llty2.to_ref(), buf)
-                });
-                lib::llvm::SetLinkage(g1, linkage);
-
-                let real_name = "_rust_extern_with_linkage_" + ident.get();
-                let g2 = real_name.with_c_str(|buf| {
-                    llvm::LLVMAddGlobal(ccx.llmod, llty.to_ref(), buf)
-                });
-                lib::llvm::SetLinkage(g2, lib::llvm::InternalLinkage);
-                llvm::LLVMSetInitializer(g2, g1);
-                g2
-            }
-        }
-        None => unsafe {
-            ident.get().with_c_str(|buf| {
-                llvm::LLVMAddGlobal(ccx.llmod, llty.to_ref(), buf)
-            })
-        }
-    }
-}
 
 pub fn register_foreign_item_fn(ccx: @CrateContext, abis: AbiSet,
                                 foreign_item: @ast::ForeignItem) -> ValueRef {