From 6608acef719ea201d8d6ce9df7d8907aa770c959 Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Fri, 11 Dec 2020 22:14:42 +0800 Subject: [PATCH] Read version of rustc that compiled proc macro With Jay Somedon --- Cargo.lock | 28 ++++++++++- crates/proc_macro_api/Cargo.toml | 2 + crates/proc_macro_api/src/lib.rs | 82 ++++++++++++++++++++++++++++---- 3 files changed, 100 insertions(+), 12 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 799127891f3..b61fd2e9812 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -80,7 +80,7 @@ dependencies = [ "cfg-if", "libc", "miniz_oxide", - "object", + "object 0.23.0", "rustc-demangle", ] @@ -1008,6 +1008,16 @@ dependencies = [ "libc", ] +[[package]] +name = "object" +version = "0.22.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d3b63360ec3cb337817c2dbd47ab4a0f170d285d8e5a2064600f3def1402397" +dependencies = [ + "flate2", + "wasmparser", +] + [[package]] name = "object" version = "0.23.0" @@ -1154,8 +1164,10 @@ dependencies = [ "crossbeam-channel", "jod-thread", "log", + "object 0.22.0", "serde", "serde_json", + "snap", "stdx", "tt", ] @@ -1168,7 +1180,7 @@ dependencies = [ "libloading", "mbe", "memmap2", - "object", + "object 0.23.0", "proc_macro_api", "proc_macro_test", "serde_derive", @@ -1540,6 +1552,12 @@ dependencies = [ "serde", ] +[[package]] +name = "snap" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc725476a1398f0480d56cd0ad381f6f32acf2642704456f8f59a35df464b59a" + [[package]] name = "socket2" version = "0.3.19" @@ -1880,6 +1898,12 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "wasmparser" +version = "0.57.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32fddd575d477c6e9702484139cf9f23dcd554b06d185ed0f56c857dd3a47aa6" + [[package]] name = "winapi" version = "0.3.9" diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml index f0972622303..a72ae236af9 100644 --- a/crates/proc_macro_api/Cargo.toml +++ b/crates/proc_macro_api/Cargo.toml @@ -19,3 +19,5 @@ jod-thread = "0.1.1" tt = { path = "../tt", version = "0.0.0" } base_db = { path = "../base_db", version = "0.0.0" } stdx = { path = "../stdx", version = "0.0.0" } +snap = "1" +object = "0.22.0" diff --git a/crates/proc_macro_api/src/lib.rs b/crates/proc_macro_api/src/lib.rs index 2ea456fb096..cec85474670 100644 --- a/crates/proc_macro_api/src/lib.rs +++ b/crates/proc_macro_api/src/lib.rs @@ -5,16 +5,11 @@ //! is used to provide basic infrastructure for communication between two //! processes: Client (RA itself), Server (the external program) -mod rpc; -mod process; pub mod msg; +mod process; +mod rpc; -use std::{ - ffi::OsStr, - io, - path::{Path, PathBuf}, - sync::Arc, -}; +use std::{ffi::OsStr, fs::read as fsread, io::{self, Read}, path::{Path, PathBuf}, sync::Arc}; use base_db::{Env, ProcMacro}; use tt::{SmolStr, Subtree}; @@ -23,6 +18,9 @@ pub use rpc::{ExpansionResult, ExpansionTask, ListMacrosResult, ListMacrosTask, ProcMacroKind}; +use object::read::{File as BinaryFile, Object, ObjectSection}; +use snap::read::FrameDecoder as SnapDecoder; + #[derive(Debug, Clone)] struct ProcMacroProcessExpander { process: Arc, @@ -71,7 +69,10 @@ pub fn extern_process( args: impl IntoIterator>, ) -> io::Result { let (thread, process) = ProcMacroProcessSrv::run(process_path, args)?; - Ok(ProcMacroClient { process: Arc::new(process), thread }) + Ok(ProcMacroClient { + process: Arc::new(process), + thread, + }) } pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec { @@ -98,8 +99,69 @@ pub fn by_dylib_path(&self, dylib_path: &Path) -> Vec { dylib_path: dylib_path.into(), }); - ProcMacro { name, kind, expander } + ProcMacro { + name, + kind, + expander, + } }) .collect() } + + // This is used inside self.read_version() to locate the ".rustc" section + // from a proc macro crate's binary file. + fn read_section<'a>(&self, dylib_binary: &'a [u8], section_name: &str) -> &'a [u8] { + BinaryFile::parse(dylib_binary) + .unwrap() + .section_by_name(section_name) + .unwrap() + .data() + .unwrap() + } + + // Check the version of rustc that was used to compile a proc macro crate's + // binary file. + // A proc macro crate binary's ".rustc" section has following byte layout: + // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes + // * ff060000 734e6150 is followed, it's the snappy format magic bytes, + // means bytes from here(including this sequence) are compressed in + // snappy compression format. Version info is here inside, so decompress + // this. + // The bytes you get after decompressing the snappy format portion has + // following layout: + // * [b'r',b'u',b's',b't',0,0,0,5] is the first 8 bytes(again) + // * [crate root bytes] next 4 bytes is to store crate root position, + // according to rustc's source code comment + // * [length byte] next 1 byte tells us how many bytes we should read next + // for the version string's utf8 bytes + // * [version string bytes encoded in utf8] <- GET THIS BOI + // * [some more bytes that we don really care but still there] :-) + // Check this issue for more about the bytes layout: + // https://github.com/rust-analyzer/rust-analyzer/issues/6174 + fn read_version(&self, dylib_path: &Path) -> String { + let dylib_binary = fsread(dylib_path).unwrap(); + + let dot_rustc = self.read_section(&dylib_binary, ".rustc"); + + let snappy_portion = &dot_rustc[8..]; + + let mut snappy_decoder = SnapDecoder::new(snappy_portion); + + // the bytes before version string bytes, so this basically is: + // 8 bytes for [b'r',b'u',b's',b't',0,0,0,5] + // 4 bytes for [crate root bytes] + // 1 byte for length of version string + // so 13 bytes in total, and we should check the 13th byte + // to know the length + let mut bytes_before_version = [0u8; 13]; + snappy_decoder + .read_exact(&mut bytes_before_version) + .unwrap(); + let length = bytes_before_version[12]; // what? can't use -1 indexing? + + let mut version_string_utf8 = vec![0u8; length as usize]; + snappy_decoder.read_exact(&mut version_string_utf8).unwrap(); + let version_string = String::from_utf8(version_string_utf8).unwrap(); + version_string + } }