compiler/rustc_incremental/src/persist/file_format.rs

   1 //! This module defines a generic file format that allows to check if a given
   2 //! file generated by incremental compilation was generated by a compatible
   3 //! compiler version. This file format is used for the on-disk version of the
   4 //! dependency graph and the exported metadata hashes.
   5 //!
   6 //! In practice "compatible compiler version" means "exactly the same compiler
   7 //! version", since the header encodes the git commit hash of the compiler.
   8 //! Since we can always just ignore the incremental compilation cache and
   9 //! compiler versions don't change frequently for the typical user, being
  10 //! conservative here practically has no downside.
  11
  12 use std::env;
  13 use std::fs;
  14 use std::io::{self, Read};
  15 use std::path::Path;
  16
  17 use rustc_serialize::opaque::{FileEncodeResult, FileEncoder};
  18 use rustc_serialize::Encoder;
  19
  20 /// The first few bytes of files generated by incremental compilation.
  21 const FILE_MAGIC: &[u8] = b"RSIC";
  22
  23 /// Change this if the header format changes.
  24 const HEADER_FORMAT_VERSION: u16 = 0;
  25
  26 /// A version string that hopefully is always different for compiler versions
  27 /// with different encodings of incremental compilation artifacts. Contains
  28 /// the Git commit hash.
  29 const RUSTC_VERSION: Option<&str> = option_env!("CFG_VERSION");
  30
  31 pub fn write_file_header(stream: &mut FileEncoder, nightly_build: bool) -> FileEncodeResult {
  32     stream.emit_raw_bytes(FILE_MAGIC)?;
  33     stream.emit_raw_bytes(&[
  34         (HEADER_FORMAT_VERSION >> 0) as u8,
  35         (HEADER_FORMAT_VERSION >> 8) as u8,
  36     ])?;
  37
  38     let rustc_version = rustc_version(nightly_build);
  39     assert_eq!(rustc_version.len(), (rustc_version.len() as u8) as usize);
  40     stream.emit_raw_bytes(&[rustc_version.len() as u8])?;
  41     stream.emit_raw_bytes(rustc_version.as_bytes())
  42 }
  43
  44 /// Reads the contents of a file with a file header as defined in this module.
  45 ///
  46 /// - Returns `Ok(Some(data, pos))` if the file existed and was generated by a
  47 ///   compatible compiler version. `data` is the entire contents of the file
  48 ///   and `pos` points to the first byte after the header.
  49 /// - Returns `Ok(None)` if the file did not exist or was generated by an
  50 ///   incompatible version of the compiler.
  51 /// - Returns `Err(..)` if some kind of IO error occurred while reading the
  52 ///   file.
  53 pub fn read_file(
  54     report_incremental_info: bool,
  55     path: &Path,
  56     nightly_build: bool,
  57 ) -> io::Result<Option<(Vec<u8>, usize)>> {
  58     let data = match fs::read(path) {
  59         Ok(data) => data,
  60         Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(None),
  61         Err(err) => return Err(err),
  62     };
  63
  64     let mut file = io::Cursor::new(data);
  65
  66     // Check FILE_MAGIC
  67     {
  68         debug_assert!(FILE_MAGIC.len() == 4);
  69         let mut file_magic = [0u8; 4];
  70         file.read_exact(&mut file_magic)?;
  71         if file_magic != FILE_MAGIC {
  72             report_format_mismatch(report_incremental_info, path, "Wrong FILE_MAGIC");
  73             return Ok(None);
  74         }
  75     }
  76
  77     // Check HEADER_FORMAT_VERSION
  78     {
  79         debug_assert!(::std::mem::size_of_val(&HEADER_FORMAT_VERSION) == 2);
  80         let mut header_format_version = [0u8; 2];
  81         file.read_exact(&mut header_format_version)?;
  82         let header_format_version =
  83             (header_format_version[0] as u16) | ((header_format_version[1] as u16) << 8);
  84
  85         if header_format_version != HEADER_FORMAT_VERSION {
  86             report_format_mismatch(report_incremental_info, path, "Wrong HEADER_FORMAT_VERSION");
  87             return Ok(None);
  88         }
  89     }
  90
  91     // Check RUSTC_VERSION
  92     {
  93         let mut rustc_version_str_len = [0u8; 1];
  94         file.read_exact(&mut rustc_version_str_len)?;
  95         let rustc_version_str_len = rustc_version_str_len[0] as usize;
  96         let mut buffer = vec![0; rustc_version_str_len];
  97         file.read_exact(&mut buffer)?;
  98
  99         if buffer != rustc_version(nightly_build).as_bytes() {
 100             report_format_mismatch(report_incremental_info, path, "Different compiler version");
 101             return Ok(None);
 102         }
 103     }
 104
 105     let post_header_start_pos = file.position() as usize;
 106     Ok(Some((file.into_inner(), post_header_start_pos)))
 107 }
 108
 109 fn report_format_mismatch(report_incremental_info: bool, file: &Path, message: &str) {
 110     debug!("read_file: {}", message);
 111
 112     if report_incremental_info {
 113         eprintln!(
 114             "[incremental] ignoring cache artifact `{}`: {}",
 115             file.file_name().unwrap().to_string_lossy(),
 116             message
 117         );
 118     }
 119 }
 120
 121 fn rustc_version(nightly_build: bool) -> String {
 122     if nightly_build {
 123         if let Some(val) = env::var_os("RUSTC_FORCE_INCR_COMP_ARTIFACT_HEADER") {
 124             return val.to_string_lossy().into_owned();
 125         }
 126     }
 127
 128     RUSTC_VERSION
 129         .expect(
 130             "Cannot use rustc without explicit version for \
 131                           incremental compilation",
 132         )
 133         .to_string()
 134 }