Support for versioned dylibs

Right now, rustc fails when trying to link against a versioned dylib
crate (e.g. libsomecrate.so.0.1).
This patch tries to address this by replacing the simple ends_with
dll_suffix check with a better one.

Author: sp1ritCS

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -2379,7 +2379,16 @@ fn add_upstream_rust_crates<'a, B: ArchiveBuilder<'a>>(
         if let Some(dir) = parent {
             cmd.include_path(&fix_windows_verbatim_for_gcc(dir));
         }
-        let filestem = cratepath.file_stem().unwrap().to_str().unwrap();
+        let filename = cratepath.file_name().unwrap().to_str().unwrap();
+        // test if dll_suffix is found within filename (should be, but if it
+        // isn't falls back to just getting the file stem). Then just gets the
+        // substring from the beginning to the suffix. This is better than just
+        // getting the filestem, as it respects versioned libraries.
+        let filestem = filename
+            .find(&sess.target.dll_suffix)
+            .map(|idx| filename.get(0..idx))
+            .flatten()
+            .unwrap_or(cratepath.file_stem().unwrap().to_str().unwrap());
         cmd.link_rust_dylib(
             Symbol::intern(&unlib(&sess.target, filestem)),
             parent.unwrap_or_else(|| Path::new("")),

compiler/rustc_metadata/src/locator.rs

@@ -365,6 +365,25 @@ impl<'a> CrateLocator<'a> {
         self.find_library_crate("", &mut seen_paths)
     }
 
+    /// Returns true if `file` has a suffix that could be a valid dylib
+    /// Example (assuming target has .so as dll_suffix):
+    ///   - `libsomecrate.asdf` -> `false`
+    ///   - `libsomecrate.so` -> `true`
+    ///   - `libsomecrate.so.0.1` -> `true`
+    ///   - `libsomecrate.so.a.4` -> `false`
+    fn test_dylib_suffix(&self, file: &str) -> bool {
+        // test if the targets dll_suffix is found within the filename. If it
+        // is check if all of the chars following it are either in range 0x30
+        // to 0x39 (0-9) or 0x2E (.).
+        match file.find(&self.target.dll_suffix) {
+            Some(idx) => file
+                .chars()
+                .skip(idx + self.target.dll_suffix.len())
+                .all(|c| c as u32 >= 0x30 && c as u32 <= 0x39 || c as u32 == 0x2E),
+            None => false,
+        }
+    }
+
     fn find_library_crate(
         &mut self,
         extra_prefix: &str,
@@ -402,7 +421,7 @@ impl<'a> CrateLocator<'a> {
                 (&file[(rlib_prefix.len())..(file.len() - ".rlib".len())], CrateFlavor::Rlib)
             } else if file.starts_with(&rlib_prefix) && file.ends_with(".rmeta") {
                 (&file[(rlib_prefix.len())..(file.len() - ".rmeta".len())], CrateFlavor::Rmeta)
-            } else if file.starts_with(&dylib_prefix) && file.ends_with(&self.target.dll_suffix) {
+            } else if file.starts_with(&dylib_prefix) && self.test_dylib_suffix(file) {
                 (
                     &file[(dylib_prefix.len())..(file.len() - self.target.dll_suffix.len())],
                     CrateFlavor::Dylib,
@@ -681,8 +700,7 @@ impl<'a> CrateLocator<'a> {
             };
 
             if file.starts_with("lib") && (file.ends_with(".rlib") || file.ends_with(".rmeta"))
-                || file.starts_with(&self.target.dll_prefix)
-                    && file.ends_with(&self.target.dll_suffix)
+                || file.starts_with(&self.target.dll_prefix) && self.test_dylib_suffix(file)
             {
                 // Make sure there's at most one rlib and at most one dylib.
                 // Note to take care and match against the non-canonicalized name: