rustc: Refactor Shv to use a canonical u64 internally

I have vague concerns about how this allocates on attempts to look at
it's representation as a str, however it doesn't appear that this is a
common case in tight loops.

Author: richo

src/librustc/metadata/encoder.rs

@@ -1998,12 +1998,12 @@ fn encode_crate_dep(rbml_w: &mut Encoder,
                     dep: decoder::CrateDep) {
     rbml_w.start_tag(tag_crate_dep);
     rbml_w.wr_tagged_str(tag_crate_dep_crate_name, &dep.name);
-    rbml_w.wr_tagged_str(tag_crate_dep_hash, dep.hash.as_str());
+    rbml_w.wr_tagged_str(tag_crate_dep_hash, &dep.hash.to_string());
     rbml_w.end_tag();
 }
 
 fn encode_hash(rbml_w: &mut Encoder, hash: &Svh) {
-    rbml_w.wr_tagged_str(tag_crate_hash, hash.as_str());
+    rbml_w.wr_tagged_str(tag_crate_hash, &hash.to_string());
 }
 
 fn encode_crate_name(rbml_w: &mut Encoder, crate_name: &str) {

src/librustc/metadata/loader.rs

@@ -601,7 +601,7 @@ impl<'a> Context<'a> {
                     info!("Rejecting via hash: expected {} got {}", *myhash, hash);
                     self.rejected_via_hash.push(CrateMismatch {
                         path: libpath.to_path_buf(),
-                        got: myhash.as_str().to_string()
+                        got: myhash.to_string()
                     });
                     false
                 } else {

src/librustc_back/svh.rs

@@ -51,19 +51,39 @@ use std::hash::{Hash, SipHasher, Hasher};
 use syntax::ast;
 use syntax::visit;
 
-#[derive(Clone, PartialEq, Debug)]
+fn hex(b: u64) -> char {
+    let b = (b & 0xf) as u8;
+    let b = match b {
+        0 ... 9 => '0' as u8 + b,
+        _ => 'a' as u8 + b - 10,
+    };
+    b as char
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Svh {
-    hash: String,
+    raw: u64,
 }
 
 impl Svh {
     pub fn new(hash: &str) -> Svh {
         assert!(hash.len() == 16);
-        Svh { hash: hash.to_string() }
+        // Ideally we'd just reverse the nibbles on LE machines during as_string, unfortunately
+        // this would break the abi so I guess we're just doing this now.
+
+        let s = if cfg!(target_endian = "big") {
+            hash.to_string()
+        } else {
+            hash.chars().rev().collect()
+        };
+
+        Svh {
+            raw: u64::from_str_radix(&s, 16).unwrap(),
+        }
     }
 
-    pub fn as_str<'a>(&'a self) -> &'a str {
-        &self.hash
+    pub fn as_string(&self) -> String {
+        (0..64).step_by(4).map(|i| hex(self.raw >> i)).collect()
     }
 
     pub fn calculate(metadata: &Vec<String>, krate: &ast::Crate) -> Svh {
@@ -100,25 +120,15 @@ impl Svh {
             attr.node.value.hash(&mut state);
         }
 
-        let hash = state.finish();
-        return Svh {
-            hash: (0..64).step_by(4).map(|i| hex(hash >> i)).collect()
-        };
-
-        fn hex(b: u64) -> char {
-            let b = (b & 0xf) as u8;
-            let b = match b {
-                0 ... 9 => '0' as u8 + b,
-                _ => 'a' as u8 + b - 10,
-            };
-            b as char
+        Svh {
+            raw: state.finish(),
         }
     }
 }
 
 impl fmt::Display for Svh {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad(self.as_str())
+        f.pad(&self.as_string())
     }
 }
 

src/librustc_trans/back/link.rs

@@ -204,7 +204,7 @@ fn symbol_hash<'tcx>(tcx: &ty::ctxt<'tcx>,
     symbol_hasher.reset();
     symbol_hasher.input_str(&link_meta.crate_name);
     symbol_hasher.input_str("-");
-    symbol_hasher.input_str(link_meta.crate_hash.as_str());
+    symbol_hasher.input_str(&link_meta.crate_hash.to_string());
     for meta in tcx.sess.crate_metadata.borrow().iter() {
         symbol_hasher.input_str(&meta[..]);
     }

src/librustc_trans/trans/debuginfo/metadata.rs

@@ -336,7 +336,7 @@ impl<'tcx> TypeMap<'tcx> {
                 cx.sess().cstore.get_crate_hash(source_def_id.krate)
             };
 
-            output.push_str(crate_hash.as_str());
+            output.push_str(&crate_hash.to_string());
             output.push_str("/");
             output.push_str(&format!("{:x}", def_id.node));