From 6608acef719ea201d8d6ce9df7d8907aa770c959 Mon Sep 17 00:00:00 2001 From: Jay Somedon Date: Fri, 11 Dec 2020 22:14:42 +0800 Subject: Read version of rustc that compiled proc macro With Jay Somedon --- crates/proc_macro_api/Cargo.toml | 2 + crates/proc_macro_api/src/lib.rs | 82 +++++++++++++++++++++++++++++++++++----- 2 files changed, 74 insertions(+), 10 deletions(-) (limited to 'crates/proc_macro_api') diff --git a/crates/proc_macro_api/Cargo.toml b/crates/proc_macro_api/Cargo.toml index f09726223..a72ae236a 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 2ea456fb0..cec854746 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 @@ use crate::process::{ProcMacroProcessSrv, ProcMacroProcessThread}; 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 @@ impl ProcMacroClient { 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 @@ impl ProcMacroClient { 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 + } } -- cgit v1.2.3