add support for xxhash, denote which algorithms cargo supports

Author: Xaeroxe

Cargo.lock

@@ -2227,7 +2227,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0c2a198fb6b0eada2a8df47933734e6d35d350665a33a3593d7164fa52c75c19"
 dependencies = [
  "cfg-if",
- "windows-targets 0.48.5",
+ "windows-targets 0.52.5",
 ]
 
 [[package]]
@@ -4776,6 +4776,7 @@ dependencies = [
  "sha2",
  "tracing",
  "unicode-width",
+ "xxhash-rust",
 ]
 
 [[package]]
@@ -6620,6 +6621,12 @@ version = "0.13.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4"
 
+[[package]]
+name = "xxhash-rust"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "927da81e25be1e1a2901d59b81b37dd2efd1fc9c9345a55007f09bf5a2d3ee03"
+
 [[package]]
 name = "xz2"
 version = "0.1.7"

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -636,6 +636,7 @@ pub fn file_metadata<'ll>(cx: &CodegenCx<'ll, '_>, source_file: &SourceFile) ->
             rustc_span::SourceFileHashAlgorithm::Md5 => llvm::ChecksumKind::MD5,
             rustc_span::SourceFileHashAlgorithm::Sha1 => llvm::ChecksumKind::SHA1,
             rustc_span::SourceFileHashAlgorithm::Sha256 => llvm::ChecksumKind::SHA256,
+            rustc_span::SourceFileHashAlgorithm::XxHash => llvm::ChecksumKind::None,
         };
         let hash_value = hex_encode(source_file.src_hash.hash_bytes());
 

compiler/rustc_session/src/options.rs

@@ -412,7 +412,8 @@ mod desc {
     pub const parse_merge_functions: &str = "one of: `disabled`, `trampolines`, or `aliases`";
     pub const parse_symbol_mangling_version: &str =
         "one of: `legacy`, `v0` (RFC 2603), or `hashed`";
-    pub const parse_src_file_hash: &str = "either `md5`, `sha1`, or `sha256`";
+    pub const parse_cargo_src_file_hash: &str = "one of `sha256` or `xxhash`";
+    pub const parse_src_file_hash: &str = "one of `md5`, `sha1` `sha256`, or `xxhash`";
     pub const parse_relocation_model: &str =
         "one of supported relocation models (`rustc --print relocation-models`)";
     pub const parse_code_model: &str = "one of supported code models (`rustc --print code-models`)";
@@ -1222,6 +1223,23 @@ mod parse {
         true
     }
 
+    pub(crate) fn parse_cargo_src_file_hash(
+        slot: &mut Option<SourceFileHashAlgorithm>,
+        v: Option<&str>,
+    ) -> bool {
+        match v.and_then(|s| SourceFileHashAlgorithm::from_str(s).ok()) {
+            Some(hash_kind) => {
+                if hash_kind.supported_in_cargo() {
+                    *slot = Some(hash_kind);
+                } else {
+                    return false;
+                }
+            }
+            _ => return false,
+        }
+        true
+    }
+
     pub(crate) fn parse_target_feature(slot: &mut String, v: Option<&str>) -> bool {
         match v {
             Some(s) => {
@@ -1609,8 +1627,8 @@ options! {
         "instrument control-flow architecture protection"),
     check_cfg_all_expected: bool = (false, parse_bool, [UNTRACKED],
         "show all expected values in check-cfg diagnostics (default: no)"),
-    checksum_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_src_file_hash, [TRACKED],
-        "hash algorithm of source files used to check freshness in cargo (`md5`, `sha1`, or `sha256`)"),
+    checksum_hash_algorithm: Option<SourceFileHashAlgorithm> = (None, parse_cargo_src_file_hash, [TRACKED],
+        "hash algorithm of source files used to check freshness in cargo (`sha256` or `xxhash`)"),
     codegen_backend: Option<String> = (None, parse_opt_string, [TRACKED],
         "the backend to use"),
     combine_cgu: bool = (false, parse_bool, [TRACKED],

compiler/rustc_span/Cargo.toml

@@ -19,4 +19,5 @@ sha1 = "0.10.0"
 sha2 = "0.10.1"
 tracing = "0.1"
 unicode-width = "0.1.4"
+xxhash-rust = { version = "0.8.10", features = ["xxh3"] }
 # tidy-alphabetical-end

compiler/rustc_span/src/lib.rs

@@ -43,6 +43,7 @@ use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_serialize::opaque::{FileEncoder, MemDecoder};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use tracing::debug;
+use xxhash_rust::xxh3;
 
 mod caching_source_map_view;
 pub mod source_map;
@@ -1458,14 +1459,25 @@ pub enum SourceFileHashAlgorithm {
     Md5,
     Sha1,
     Sha256,
+    XxHash,
+}
+
+impl SourceFileHashAlgorithm {
+    pub fn supported_in_cargo(&self) -> bool {
+        match self {
+            Self::Md5 | Self::Sha1 => false,
+            Self::Sha256 | Self::XxHash => true,
+        }
+    }
 }
 
 impl Display for SourceFileHashAlgorithm {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(match self {
-            SourceFileHashAlgorithm::Md5 => "md5",
-            SourceFileHashAlgorithm::Sha1 => "sha1",
-            SourceFileHashAlgorithm::Sha256 => "sha256",
+            Self::Md5 => "md5",
+            Self::Sha1 => "sha1",
+            Self::Sha256 => "sha256",
+            Self::XxHash => "xxhash",
         })
     }
 }
@@ -1478,6 +1490,7 @@ impl FromStr for SourceFileHashAlgorithm {
             "md5" => Ok(SourceFileHashAlgorithm::Md5),
             "sha1" => Ok(SourceFileHashAlgorithm::Sha1),
             "sha256" => Ok(SourceFileHashAlgorithm::Sha256),
+            "xxhash" => Ok(SourceFileHashAlgorithm::XxHash),
             _ => Err(()),
         }
     }
@@ -1517,6 +1530,9 @@ impl SourceFileHash {
             SourceFileHashAlgorithm::Sha256 => {
                 value.copy_from_slice(&Sha256::digest(data));
             }
+            SourceFileHashAlgorithm::XxHash => {
+                value.copy_from_slice(&xxh3::xxh3_128(data).to_be_bytes());
+            }
         };
         hash
     }
@@ -1551,6 +1567,16 @@ impl SourceFileHash {
         }
 
         match kind {
+            SourceFileHashAlgorithm::XxHash => {
+                digest(
+                    xxh3::Xxh3::new(),
+                    |h, b| h.update(b),
+                    |h, out| out.copy_from_slice(&h.digest128().to_be_bytes()),
+                    src,
+                    &mut buf,
+                    value,
+                )?;
+            }
             SourceFileHashAlgorithm::Sha256 => {
                 digest(
                     Sha256::new(),
@@ -1607,6 +1633,7 @@ impl SourceFileHash {
             SourceFileHashAlgorithm::Md5 => 16,
             SourceFileHashAlgorithm::Sha1 => 20,
             SourceFileHashAlgorithm::Sha256 => 32,
+            SourceFileHashAlgorithm::XxHash => 16,
         }
     }
 }