From ba7b47eb55028c405c2852a4378a31c74fb96902 Mon Sep 17 00:00:00 2001 From: Richo Healey Date: Fri, 26 Jun 2015 10:32:27 -0700 Subject: [PATCH 1/5] rustc_driver: Fix incorrect comment --- src/librustc_driver/lib.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 96d1ab23ad523..a9787987611f7 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -481,8 +481,7 @@ pub fn commit_date_str() -> Option<&'static str> { option_env!("CFG_VER_DATE") } -/// Prints version information and returns None on success or an error -/// message on panic. +/// Prints version information pub fn version(binary: &str, matches: &getopts::Matches) { let verbose = matches.opt_present("verbose"); From d7eb7a6691c0de31c8a7f946dd2c62de46d4de8b Mon Sep 17 00:00:00 2001 From: Richo Healey Date: Fri, 26 Jun 2015 10:52:53 -0700 Subject: [PATCH 2/5] Update comment for new location of unwind --- src/rt/rust_try.ll | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/rt/rust_try.ll b/src/rt/rust_try.ll index 226dc55cb8d5a..845fc097cdc78 100644 --- a/src/rt/rust_try.ll +++ b/src/rt/rust_try.ll @@ -12,7 +12,7 @@ ; When f(...) returns normally, the return value is null. ; When f(...) throws, the return value is a pointer to the caught exception object. -; See also: libstd/rt/unwind.rs +; See also: libstd/rt/unwind/mod.rs define i8* @rust_try(void (i8*)* %f, i8* %env) { From aff24e1e74114469ad665fa43efa6ea017018163 Mon Sep 17 00:00:00 2001 From: Richo Healey Date: Sat, 27 Jun 2015 00:53:40 -0700 Subject: [PATCH 3/5] 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. --- src/librustc/metadata/encoder.rs | 4 +- src/librustc/metadata/loader.rs | 2 +- src/librustc_back/svh.rs | 46 +++++++++++-------- src/librustc_trans/back/link.rs | 2 +- .../trans/debuginfo/metadata.rs | 2 +- 5 files changed, 33 insertions(+), 23 deletions(-) diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index b844717e61388..63450f12d162b 100644 --- a/src/librustc/metadata/encoder.rs +++ b/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) { diff --git a/src/librustc/metadata/loader.rs b/src/librustc/metadata/loader.rs index 2af3c393868d8..04b659c30583f 100644 --- a/src/librustc/metadata/loader.rs +++ b/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 { diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index f9416d53a8fa3..d8a41fa745a92 100644 --- a/src/librustc_back/svh.rs +++ b/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, 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()) } } diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index cf5feabcc57e2..a95e877fb16f1 100644 --- a/src/librustc_trans/back/link.rs +++ b/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[..]); } diff --git a/src/librustc_trans/trans/debuginfo/metadata.rs b/src/librustc_trans/trans/debuginfo/metadata.rs index 1fbbf0763aa53..efc282a4084d5 100644 --- a/src/librustc_trans/trans/debuginfo/metadata.rs +++ b/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)); From 75219e16fc3314fe1a1f3bac6593b4acc7859e21 Mon Sep 17 00:00:00 2001 From: Richo Healey Date: Fri, 26 Jun 2015 15:28:40 -0700 Subject: [PATCH 4/5] rustc_back: impl Hash for Svh --- src/librustc_back/svh.rs | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index d8a41fa745a92..47b8d6016ec7f 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -126,6 +126,14 @@ impl Svh { } } +impl Hash for Svh { + fn hash(&self, state: &mut H) where H: Hasher { + // We have to hash a &str since that's what the old implementations did, and otherwise we + // break the abi + &self.to_string()[..].hash(state); + } +} + impl fmt::Display for Svh { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad(&self.as_string()) From dd417325f8cce95d7a02fbf1eb69fe210037be1e Mon Sep 17 00:00:00 2001 From: Richo Healey Date: Sat, 27 Jun 2015 18:21:36 -0700 Subject: [PATCH 5/5] rustc_back: Remove unused code Downstream consumers of Svh now use the ToString and Hash traits whenever possible --- src/librustc_back/svh.rs | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-) diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 47b8d6016ec7f..ef60a68a741a4 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -51,15 +51,6 @@ use std::hash::{Hash, SipHasher, Hasher}; use syntax::ast; use syntax::visit; -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 { raw: u64, @@ -68,7 +59,7 @@ pub struct Svh { impl Svh { pub fn new(hash: &str) -> Svh { assert!(hash.len() == 16); - // Ideally we'd just reverse the nibbles on LE machines during as_string, unfortunately + // Ideally we'd just reverse the nibbles on LE machines during to_string, unfortunately // this would break the abi so I guess we're just doing this now. let s = if cfg!(target_endian = "big") { @@ -82,10 +73,6 @@ impl Svh { } } - pub fn as_string(&self) -> String { - (0..64).step_by(4).map(|i| hex(self.raw >> i)).collect() - } - pub fn calculate(metadata: &Vec, krate: &ast::Crate) -> Svh { // FIXME (#14132): This is better than it used to be, but it still not // ideal. We now attempt to hash only the relevant portions of the @@ -136,7 +123,7 @@ impl Hash for Svh { impl fmt::Display for Svh { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.pad(&self.as_string()) + f.pad(&self.to_string()) } }