More work on proper linkage name-mangling. Almost right, aside from version numbers.

Author: graydon

src/comp/back/link.rs

@@ -1,8 +1,18 @@
 import driver::session;
 import lib::llvm::llvm;
 import middle::trans;
+import middle::metadata;
+import middle::ty;
 import std::str;
 import std::fs;
+import std::vec;
+import std::option;
+import option::some;
+import option::none;
+import std::sha1::sha1;
+import std::sort;
+import trans::crate_ctxt;
+import front::ast;
 
 import lib::llvm::llvm::ModuleRef;
 import lib::llvm::llvm::ValueRef;
@@ -49,7 +59,7 @@ fn link_intrinsics(session::session sess, ModuleRef llmod) {
 
     auto linkres = llvm::LLVMLinkModules(llmod, llintrinsicsmod);
     llvm::LLVMDisposeModule(llintrinsicsmod);
-    
+
     if (linkres == False) {
         llvm_err(sess, "couldn't link the module with the intrinsics");
         fail;
@@ -58,7 +68,7 @@ fn link_intrinsics(session::session sess, ModuleRef llmod) {
 
 mod write {
     fn is_object_or_assembly_or_exe(output_type ot) -> bool {
-        if ( (ot == output_type_assembly) || 
+        if ( (ot == output_type_assembly) ||
              (ot == output_type_object) ||
              (ot == output_type_exe) ) {
             ret true;
@@ -218,3 +228,235 @@ mod write {
     }
 }
 
+/*
+ * Name mangling and its relationship to metadata. This is complex. Read
+ * carefully.
+ *
+ * The semantic model of Rust linkage is, broadly, that "there's no global
+ * namespace" between crates. Our aim is to preserve the illusion of this
+ * model despite the fact that it's not *quite* possible to implement on
+ * modern linkers. We initially didn't use system linkers at all, but have
+ * been convinced of their utility.
+ *
+ * There are a few issues to handle:
+ *
+ *  - Linkers operate on a flat namespace, so we have to flatten names.
+ *    We do this using the C++ namespace-mangling technique. Foo::bar
+ *    symbols and such.
+ *
+ *  - Symbols with the same name but different types need to get different
+ *    linkage-names. We do this by hashing a string-encoding of the type into
+ *    a fixed-size (currently 16-byte hex) cryptographic hash function (CHF:
+ *    we use SHA1) to "prevent collisions". This is not airtight but 16 hex
+ *    digits on uniform probability means you're going to need 2**32 same-name
+ *    symbols in the same process before you're even hitting birthday-paradox
+ *    collision probability.
+ *
+ *  - Symbols in dirrerent crates but with same names "within" the crate need
+ *    to get different linkage-names.
+ *
+ * So here is what we do:
+ *
+ *  - Separate the meta tags into two sets: exported and local. Only work with
+ *    the exported ones when considering linkage.
+ *
+ *  - Consider two exported tags as special (and madatory): name and vers.
+ *    Every crate gets them; if it doesn't name them explicitly we infer them
+ *    as basename(crate) and "0.1", respectively. Call these CNAME, CVERS.
+ *
+ *  - Define CMETA as all the non-name, non-vers exported meta tags in the
+ *    crate (in sorted order).
+ *
+ *  - Define CMH as hash(CMETA).
+ *
+ *  - Compile our crate to lib CNAME-CMH-CVERS.so
+ *
+ *  - Define STH(sym) as hash(CNAME, CMH, type_str(sym))
+ *
+ *  - Suffix a mangled sym with ::STH@CVERS, so that it is unique in the
+ *    name, non-name metadata, and type sense, and versioned in the way
+ *    system linkers understand.
+ *
+ */
+
+
+iter crate_export_metas(ast::crate c) -> @ast::meta_item {
+    for (@ast::crate_directive cdir in c.node.directives) {
+        alt (cdir.node) {
+            case (ast::cdir_meta(?v, ?mis)) {
+                if (v == ast::export_meta) {
+                    for (@ast::meta_item mi in mis) {
+                        put mi;
+                    }
+                }
+            }
+            case (_) {}
+        }
+    }
+}
+fn get_crate_meta(&session::session sess,
+                  &ast::crate c, str k, str default,
+                  bool warn_default) -> str {
+    let vec[@ast::meta_item] v = [];
+    for each (@ast::meta_item mi in crate_export_metas(c)) {
+        if (mi.node.name == k) {
+            v += [mi];
+        }
+    }
+    alt (vec::len(v)) {
+        case (0u) {
+            if (warn_default) {
+                sess.warn(#fmt("missing meta '%s', using '%s' as default",
+                               k, default));
+            }
+            ret default;
+        }
+        case (1u) {
+            ret v.(0).node.value;
+        }
+        case (_) {
+            sess.span_err(v.(1).span, #fmt("duplicate meta '%s'", k));
+        }
+    }
+}
+
+// This calculates CMH as defined above
+fn crate_meta_extras_hash(sha1 sha, &ast::crate crate) -> str {
+    fn lteq(&@ast::meta_item ma,
+            &@ast::meta_item mb) -> bool {
+        ret ma.node.name <= mb.node.name;
+    }
+
+    fn len_and_str(&str s) -> str {
+        ret #fmt("%u_%s", str::byte_len(s), s);
+    }
+
+    let vec[mutable @ast::meta_item] v = [mutable];
+    for each (@ast::meta_item mi in crate_export_metas(crate)) {
+        if (mi.node.name != "name" &&
+            mi.node.name != "vers") {
+            v += [mutable mi];
+        }
+    }
+    sort::quick_sort(lteq, v);
+    sha.reset();
+    for (@ast::meta_item m in v) {
+        sha.input_str(len_and_str(m.node.name));
+        sha.input_str(len_and_str(m.node.value));
+    }
+    ret truncated_sha1_result(sha);
+}
+
+fn crate_meta_name(&session::session sess, &ast::crate crate,
+                       &str output) -> str {
+    auto os = str::split(fs::basename(output), '.' as u8);
+    assert vec::len(os) >= 2u;
+    vec::pop(os);
+    ret get_crate_meta(sess, crate, "name", str::connect(os, "."),
+                       sess.get_opts().shared);
+}
+
+fn crate_meta_vers(&session::session sess, &ast::crate crate) -> str {
+    ret get_crate_meta(sess, crate, "vers", "0.0",
+                       sess.get_opts().shared);
+}
+
+fn truncated_sha1_result(sha1 sha) -> str {
+    ret str::substr(sha.result_str(), 0u, 16u);
+}
+
+
+
+// This calculates STH for a symbol, as defined above
+fn symbol_hash(ty::ctxt tcx, sha1 sha, &ty::t t,
+               str crate_meta_name,
+               str crate_meta_extras_hash) -> str {
+    // NB: do *not* use abbrevs here as we want the symbol names
+    // to be independent of one another in the crate.
+    auto cx = @rec(ds=metadata::def_to_str, tcx=tcx,
+                   abbrevs=metadata::ac_no_abbrevs);
+    sha.reset();
+    sha.input_str(crate_meta_name);
+    sha.input_str("-");
+    sha.input_str(crate_meta_name);
+    sha.input_str("-");
+    sha.input_str(metadata::Encode::ty_str(cx, t));
+    auto hash = truncated_sha1_result(sha);
+    // Prefix with _ so that it never blends into adjacent digits
+    ret "_" + hash;
+}
+
+fn get_symbol_hash(&@crate_ctxt ccx, &ty::t t) -> str {
+    auto hash = "";
+    alt (ccx.type_sha1s.find(t)) {
+        case (some(?h)) { hash = h; }
+        case (none) {
+            hash = symbol_hash(ccx.tcx, ccx.sha, t,
+                               ccx.crate_meta_name,
+                               ccx.crate_meta_extras_hash);
+            ccx.type_sha1s.insert(t, hash);
+        }
+    }
+    ret hash;
+}
+
+
+fn mangle(&vec[str] ss) -> str {
+
+    // Follow C++ namespace-mangling style
+
+    auto n = "_ZN"; // Begin name-sequence.
+
+    for (str s in ss) {
+        n += #fmt("%u%s", str::byte_len(s), s);
+    }
+
+    n += "E"; // End name-sequence.
+    ret n;
+}
+
+
+fn exported_name(&vec[str] path, &str hash, &str vers) -> str {
+    // FIXME: versioning isn't working yet
+    ret mangle(path + [hash]); //  + "@" + vers;
+}
+
+fn mangle_exported_name(&@crate_ctxt ccx, &vec[str] path,
+                        &ty::t t) -> str {
+    auto hash = get_symbol_hash(ccx, t);
+    ret exported_name(path, hash, ccx.crate_meta_vers);
+}
+
+fn mangle_internal_name_by_type_only(&@crate_ctxt ccx, &ty::t t,
+                                     &str name) -> str {
+    auto f = metadata::def_to_str;
+    auto cx = @rec(ds=f, tcx=ccx.tcx, abbrevs=metadata::ac_no_abbrevs);
+    auto s = ty::ty_to_short_str(ccx.tcx, t);
+
+    auto hash = get_symbol_hash(ccx, t);
+    ret mangle([name, s, hash]);
+}
+
+fn mangle_internal_name_by_path_and_seq(&@crate_ctxt ccx, &vec[str] path,
+                                       &str flav) -> str {
+    ret mangle(path + [ccx.names.next(flav)]);
+}
+
+fn mangle_internal_name_by_path(&@crate_ctxt ccx, &vec[str] path) -> str {
+    ret mangle(path);
+}
+
+fn mangle_internal_name_by_seq(&@crate_ctxt ccx, &str flav) -> str {
+    ret ccx.names.next(flav);
+}
+
+//
+// Local Variables:
+// mode: rust
+// fill-column: 78;
+// indent-tabs-mode: nil
+// c-basic-offset: 4
+// buffer-file-coding-system: utf-8-unix
+// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
+// End:
+//

src/comp/driver/session.rs

@@ -6,6 +6,9 @@ import std::uint;
 import std::term;
 import std::io;
 import std::map;
+import std::option;
+import std::option::some;
+import std::option::none;
 
 tag os {
     os_win32;
@@ -48,9 +51,16 @@ fn span_to_str(span sp, codemap::codemap cm) -> str {
               lo.col, hi.line, hi.col));
 }
 
-fn emit_diagnostic(span sp, str msg, str kind, u8 color,
+fn emit_diagnostic(option::t[span] sp, str msg, str kind, u8 color,
                    codemap::codemap cm) {
-    io::stdout().write_str(span_to_str(sp, cm) + ": ");
+    auto ss = "<input>:0:0:0:0";
+    alt (sp) {
+        case (some(?ssp)) {
+            ss = span_to_str(ssp, cm);
+        }
+        case (none) {}
+    }
+    io::stdout().write_str(ss + ": ");
 
     if (term::color_supported()) {
         term::fg(io::stdout().get_buf_writer(), color);
@@ -85,12 +95,12 @@ state obj session(ast::crate_num cnum,
 
     fn span_err(span sp, str msg) -> ! {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        emit_diagnostic(sp, msg, "error", 9u8, cm);
+        emit_diagnostic(some(sp), msg, "error", 9u8, cm);
         fail;
     }
 
     fn err(str msg) -> ! {
-        log_err #fmt("error: %s", msg);
+        emit_diagnostic(none[span], msg, "error", 9u8, cm);
         fail;
     }
 
@@ -103,29 +113,32 @@ state obj session(ast::crate_num cnum,
 
     fn span_warn(span sp, str msg) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        emit_diagnostic(sp, msg, "warning", 11u8, cm);
+        emit_diagnostic(some(sp), msg, "warning", 11u8, cm);
+    }
+
+    fn warn(str msg) {
+        emit_diagnostic(none[span], msg, "warning", 11u8, cm);
     }
 
     fn span_note(span sp, str msg) {
         // FIXME: Use constants, but rustboot doesn't know how to export them.
-        emit_diagnostic(sp, msg, "note", 10u8, cm);
+        emit_diagnostic(some(sp), msg, "note", 10u8, cm);
+    }
+
+    fn span_bug(span sp, str msg) -> ! {
+        self.span_err(sp, #fmt("internal compiler error %s", msg));
     }
 
     fn bug(str msg) -> ! {
-        log_err #fmt("error: internal compiler error %s", msg);
-        fail;
+        self.err(#fmt("internal compiler error %s", msg));
     }
 
     fn span_unimpl(span sp, str msg) -> ! {
-        // FIXME: Use constants, but rustboot doesn't know how to export them.
-        emit_diagnostic(sp, "internal compiler error: unimplemented " + msg,
-                        "error", 9u8, cm);
-        fail;
+        self.span_bug(sp, "unimplemented " + msg);
     }
-    
+
     fn unimpl(str msg) -> ! {
-        log_err #fmt("error: unimplemented %s", msg);
-        fail;
+        self.bug("unimplemented " + msg);
     }
 
     fn get_external_crate(int num) -> crate_metadata {

src/comp/front/ast.rs

@@ -71,6 +71,11 @@ type crate = spanned[crate_];
 type crate_ = rec(vec[@crate_directive] directives,
                   _mod module);
 
+tag meta_visibility {
+    export_meta;
+    local_meta;
+}
+
 tag crate_directive_ {
     cdir_expr(@expr);
     // FIXME: cdir_let should be eliminated
@@ -80,7 +85,7 @@ tag crate_directive_ {
     cdir_src_mod(ident, option::t[filename]);
     cdir_dir_mod(ident, option::t[filename], vec[@crate_directive]);
     cdir_view_item(@view_item);
-    cdir_meta(vec[@meta_item]);
+    cdir_meta(meta_visibility, vec[@meta_item]);
     cdir_syntax(path);
     cdir_auth(path, _auth);
 }

src/comp/front/eval.rs

@@ -418,8 +418,13 @@ fn eval_crate_directive(ctx cx,
             vec::push[@ast::view_item](view_items, vi);
         }
 
-        case (ast::cdir_meta(?mi)) {
-            cx.sess.add_metadata(mi);
+        case (ast::cdir_meta(?vi, ?mi)) {
+            // FIXME: we should actually record, for documentation-sake,
+            // the metadata that's not exported. It would be nice to have
+            // compiled-in to the target crate, not just in theh AST.
+            if (vi == ast::export_meta) {
+                cx.sess.add_metadata(mi);
+            }
         }
 
         case (ast::cdir_syntax(?pth)) {}