transpile: add --emit-c-decl-map flag to emit map from translated item to the corresponding C definition

Author: fw-immunant

c2rust-transpile/src/c_ast/mod.rs

@@ -299,6 +299,39 @@ impl TypedAstContext {
         }
     }
 
+    /// Construct a map from top-level decls in the main file to their source ranges.
+    pub fn top_decl_locs(&self) -> IndexMap<CDeclId, (SrcLoc, SrcLoc)> {
+        let mut name_loc_map = IndexMap::new();
+        let mut prev_src_loc = SrcLoc {
+            fileid: 0,
+            line: 0,
+            column: 0,
+        };
+        for (decl_id, decl) in &self.c_decls {
+            let begin_loc: SrcLoc = decl.begin_loc().expect("no begin loc for top-level decl");
+            let end_loc: SrcLoc = decl.end_loc().expect("no end loc for top-level decl");
+
+            // If encountering a new file, reset end of last top-level decl.
+            if prev_src_loc.fileid != begin_loc.fileid {
+                prev_src_loc = SrcLoc {
+                    fileid: begin_loc.fileid,
+                    line: 1,
+                    column: 1,
+                }
+            }
+
+            // Include only decls from the main file.
+            if self.c_decls_top.contains(decl_id)
+                && self.get_source_path(decl) == Some(&self.main_file)
+            {
+                let entry = (prev_src_loc, end_loc);
+                name_loc_map.insert(*decl_id, entry);
+            }
+            prev_src_loc = end_loc;
+        }
+        name_loc_map
+    }
+
     pub fn iter_decls(&self) -> indexmap::map::Iter<'_, CDeclId, CDecl> {
         self.c_decls.iter()
     }

c2rust-transpile/src/lib.rs

@@ -72,6 +72,7 @@ pub struct TranspilerConfig {
     pub dump_structures: bool,
     pub verbose: bool,
     pub debug_ast_exporter: bool,
+    pub emit_c_decl_map: bool,
 
     // Options that control translation
     pub incremental_relooper: bool,
@@ -599,9 +600,30 @@ fn transpile_single(
     }
 
     // Perform the translation
-    let (translated_string, pragmas, crates) =
+    let (translated_string, maybe_decl_map, pragmas, crates) =
         translator::translate(typed_context, tcfg, input_path);
 
+    if let Some(decl_map) = maybe_decl_map {
+        let decl_map_path = output_path.with_extension("c_decls.json");
+        let file = match File::create(&decl_map_path) {
+            Ok(file) => file,
+            Err(e) => panic!(
+                "Unable to open file {} for writing: {}",
+                output_path.display(),
+                e
+            ),
+        };
+
+        match serde_json::ser::to_writer(file, &decl_map) {
+            Ok(()) => (),
+            Err(e) => panic!(
+                "Unable to write C declaration map to file {}: {}",
+                output_path.display(),
+                e
+            ),
+        };
+    }
+
     let mut file = match File::create(&output_path) {
         Ok(file) => file,
         Err(e) => panic!(

c2rust-transpile/src/translator/mod.rs

@@ -9,6 +9,7 @@ use dtoa;
 use failure::{err_msg, format_err, Fail};
 use indexmap::indexmap;
 use indexmap::{IndexMap, IndexSet};
+use itertools::Itertools;
 use log::{error, info, trace, warn};
 use proc_macro2::{Punct, Spacing::*, Span, TokenStream, TokenTree};
 use syn::spanned::Spanned as _;
@@ -492,11 +493,13 @@ pub fn translate_failure(tcfg: &TranspilerConfig, msg: &str) {
     }
 }
 
+type DeclMap = IndexMap<String, String>;
+
 pub fn translate(
     ast_context: TypedAstContext,
     tcfg: &TranspilerConfig,
     main_file: &Path,
-) -> (String, PragmaVec, CrateSet) {
+) -> (String, Option<DeclMap>, PragmaVec, CrateSet) {
     let mut t = Translation::new(ast_context, tcfg, main_file);
     let ctx = ExprContext {
         used: true,
@@ -513,6 +516,8 @@ pub fn translate(
     {
         t.locate_comments();
 
+        let decl_source_ranges = t.ast_context.top_decl_locs();
+
         // Headers often pull in declarations that are unused;
         // we simplify the translator output by omitting those.
         t.ast_context
@@ -762,6 +767,80 @@ pub fn translate(
             })
             .collect::<HashMap<_, _>>();
 
+        // Generate a map from Rust items to the source code of their C declarations.
+        let decl_map = if tcfg.emit_c_decl_map {
+            let mut path_to_c_source_range: HashMap<&Ident, (SrcLoc, SrcLoc)> = Default::default();
+            for (decl, source_range) in decl_source_ranges {
+                match converted_decls.get(&decl) {
+                    Some(ConvertedDecl::ForeignItem(item)) => {
+                        path_to_c_source_range
+                            .insert(foreign_item_ident_vis(&*item).unwrap().0, source_range);
+                    }
+                    Some(ConvertedDecl::Item(item)) => {
+                        path_to_c_source_range.insert(item_ident(&*item).unwrap(), source_range);
+                    }
+                    Some(ConvertedDecl::Items(items)) => {
+                        for item in items {
+                            path_to_c_source_range
+                                .insert(item_ident(&*item).unwrap(), source_range);
+                        }
+                    }
+                    Some(ConvertedDecl::NoItem) => {}
+                    None => eprintln!("failed to convert top-level decl {decl:?}!"),
+                }
+            }
+
+            let file_content =
+                std::fs::read(&t.ast_context.get_file_path(t.main_file).unwrap()).unwrap();
+            let line_end_offsets = //memchr::memchr_iter(file_content, '\n')
+                file_content.iter().positions(|c| *c == b'\n')
+                .collect::<Vec<_>>();
+
+            /// Convert a source location line/column into a byte offset, given the positions of each newline in the file.
+            fn src_loc_to_byte_offset(line_end_offsets: &[usize], loc: SrcLoc) -> usize {
+                let line_offset = line_end_offsets
+                    .get(loc.line as usize - 2) // end of the previous line; for line < 1, index out of bounds
+                    .map(|x| x + 1) // increment end of the prev line to find start of this one
+                    .unwrap_or(0); // if we indexed out of bounds, start at byte 0
+                line_offset + (loc.column as usize).saturating_sub(1)
+            }
+
+            // Slice into the source file, fixing up the ends to account for Clang AST quirks.
+            let slice_decl_with_fixups = |begin, end| -> &[u8] {
+                let mut begin_offset = src_loc_to_byte_offset(&line_end_offsets, begin);
+                let mut end_offset = src_loc_to_byte_offset(&line_end_offsets, end);
+                const VT: u8 = 11;
+                /* Skip whitespace and any trailing semicolons after the previous decl. */
+                while let Some(b'\t' | b'\n' | &VT | b'\r' | b' ' | b';') =
+                    file_content.get(begin_offset)
+                {
+                    begin_offset += 1;
+                }
+
+                // Extend to include a single trailing semicolon if this decl is not a block
+                // (e.g., a variable declaration).
+                if file_content.get(end_offset - 1) != Some(&b'}')
+                    && file_content.get(end_offset) == Some(&b';')
+                {
+                    end_offset += 1;
+                }
+
+                &file_content[begin_offset..end_offset]
+            };
+
+            let item_path_to_c_source: IndexMap<_, _> = path_to_c_source_range
+                .into_iter()
+                .map(|(ident, (begin, end))| {
+                    let path = ident.to_string();
+                    let c_src = std::str::from_utf8(slice_decl_with_fixups(begin, end)).unwrap();
+                    (path, c_src.to_owned())
+                })
+                .collect();
+            Some(item_path_to_c_source)
+        } else {
+            None
+        };
+
         t.ast_context.sort_top_decls_for_emitting();
 
         for top_id in &t.ast_context.c_decls_top {
@@ -926,7 +1005,7 @@ pub fn translate(
             .copied()
             .collect();
 
-        (translation, pragmas, crates)
+        (translation, decl_map, pragmas, crates)
     }
 }
 

c2rust/src/bin/c2rust-transpile.rs

@@ -36,6 +36,10 @@ struct Args {
     #[clap(long)]
     debug_ast_exporter: bool,
 
+    /// Dump map of top-level C decls
+    #[clap(long)]
+    emit_c_decl_map: bool,
+
     /// Verbose mode
     #[clap(short = 'v', long)]
     verbose: bool,
@@ -205,6 +209,7 @@ fn main() {
         dump_cfg_liveness: args.dump_cfgs_liveness,
         dump_structures: args.dump_structures,
         debug_ast_exporter: args.debug_ast_exporter,
+        emit_c_decl_map: args.emit_c_decl_map,
         verbose: args.verbose,
 
         incremental_relooper: !args.no_incremental_relooper,