Add dummy definition for referenced never-defined structs

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -23,6 +23,7 @@ std::unordered_set<std::string> Converter::record_decls_;
 std::unordered_set<std::string> Converter::decl_ids_;
 std::unordered_set<std::string> Converter::globals_;
 std::unordered_set<std::string> Converter::abstract_structs_;
+std::unordered_map<std::string, std::string> Converter::referenced_records_;
 
 void Converter::ConvertUniquePtrDeref(clang::CXXOperatorCallExpr *expr) {
   bool is_star = expr->getOperator() == clang::OverloadedOperatorKind::OO_Star;
@@ -53,6 +54,19 @@ use std::rc::Rc;
 )");
 }
 
+std::string Converter::EmitOpaqueRecordMarkers() {
+  std::string out;
+  for (const auto &[id, name] : referenced_records_) {
+    if (record_decls_.contains(id)) {
+      continue;
+    }
+    out += "#[repr(C)] pub struct ";
+    out += name;
+    out += " { _opaque: [u8; 0] }\n";
+  }
+  return out;
+}
+
 bool Converter::VisitRecoveryExpr(clang::RecoveryExpr *expr) {
   llvm::errs() << "RecoveryExpr: ";
   expr->dump();
@@ -160,7 +174,11 @@ bool Converter::VisitRecordType(clang::RecordType *type) {
     }
   }
 
-  StrCat(GetRecordName(decl));
+  auto name = GetRecordName(decl);
+  StrCat(name);
+  if (!ctx_.getSourceManager().isInSystemHeader(decl->getLocation())) {
+    referenced_records_.try_emplace(GetID(decl), std::move(name));
+  }
   Mapper::AddRuleForUserDefinedType(decl);
   return false;
 }

cpp2rust/converter/converter.h

@@ -51,6 +51,10 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitFilePreamble();
 
+  // Returns Rust text emitting `pub struct N { _opaque: [u8; 0] }` for each
+  // record name referenced by some TU but never defined by any.
+  static std::string EmitOpaqueRecordMarkers();
+
   virtual bool VisitBuiltinType(clang::BuiltinType *type);
 
   virtual bool VisitRecordType(clang::RecordType *type);
@@ -646,6 +650,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   static std::unordered_set<std::string> decl_ids_;
   static std::unordered_set<std::string> record_decls_;
   static std::unordered_set<std::string> abstract_structs_;
+  static std::unordered_map<std::string, std::string> referenced_records_;
 
   enum class ExprKind : uint8_t {
     Callee,

cpp2rust/cpp2rust_lib.cpp

@@ -10,6 +10,7 @@
 #include <filesystem>
 
 #include "compat/platform_flags.h"
+#include "converter/converter.h"
 #include "frontend_action.h"
 
 namespace cpp2rust {
@@ -29,6 +30,7 @@ std::string TranspileSrc(std::string_view cc_code, Model model,
                                        rules_dir),
       cc_code, tool_args, std::filesystem::path(filename).filename().string(),
       filename.ends_with(".c") ? CLANG_C_COMPILER : CLANG_CXX_COMPILER);
+  rs_code += Converter::EmitOpaqueRecordMarkers();
   return rs_code;
 }
 
@@ -68,6 +70,7 @@ std::string TranspileDir(std::string_view build_dir, Model model,
   std::string rs_code;
   FrontendActionFactory factory(rs_code, model, rules_dir);
   Tool.run(&factory);
+  rs_code += Converter::EmitOpaqueRecordMarkers();
   return rs_code;
 }
 } // namespace cpp2rust

tests/multi-file/opaque_forward_decl/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.16)
+project(opaque_forward_decl LANGUAGES C)
+add_executable(app a.c b.c)

tests/multi-file/opaque_forward_decl/a.c

@@ -0,0 +1,12 @@
+#include <assert.h>
+#include <stddef.h>
+
+#include "header.h"
+
+int main(void) {
+  struct container c = {NULL, 42};
+  touch(&c);
+  assert(c.x == 42);
+  assert(c.p == NULL);
+  return 0;
+}

tests/multi-file/opaque_forward_decl/b.c

@@ -0,0 +1,6 @@
+#include "header.h"
+
+void touch(struct container *c) {
+  /* read the opaque pointer field without dereferencing the opaque type */
+  (void)c->p;
+}

tests/multi-file/opaque_forward_decl/header.h

@@ -0,0 +1,11 @@
+#pragma once
+
+/* Forward declaration only; no full definition exists anywhere in the build. */
+struct opaque;
+
+struct container {
+  struct opaque *p;
+  int x;
+};
+
+void touch(struct container *c);

tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs

@@ -0,0 +1,38 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+#[derive(Default)]
+pub struct container {
+    pub p: Value<Ptr<opaque>>,
+    pub x: Value<i32>,
+}
+impl ByteRepr for container {}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let c: Value<container> = Rc::new(RefCell::new(container {
+        p: Rc::new(RefCell::new(Ptr::<opaque>::null())),
+        x: Rc::new(RefCell::new(42)),
+    }));
+    ({
+        let _c: Ptr<container> = (c.as_pointer());
+        touch_0(_c)
+    });
+    assert!(((((*(*c.borrow()).x.borrow()) == 42) as i32) != 0));
+    assert!(((((*(*c.borrow()).p.borrow()).is_null()) as i32) != 0));
+    return 0;
+}
+pub fn touch_0(c: Ptr<container>) {
+    let c: Value<Ptr<container>> = Rc::new(RefCell::new(c));
+    (*(*(*c.borrow()).upgrade().deref()).p.borrow()).clone();
+}
+#[repr(C)]
+pub struct opaque {
+    _opaque: [u8; 0],
+}

tests/multi-file/opaque_forward_decl/out/unsafe/opaque_forward_decl.rs

@@ -0,0 +1,39 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct container {
+    pub p: *mut opaque,
+    pub x: i32,
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut c: container = container {
+        p: std::ptr::null_mut(),
+        x: 42,
+    };
+    (unsafe {
+        let _c: *mut container = (&mut c as *mut container);
+        touch_0(_c)
+    });
+    assert!(((((c.x) == (42)) as i32) != 0));
+    assert!(((((c.p).is_null()) as i32) != 0));
+    return 0;
+}
+pub unsafe fn touch_0(mut c: *mut container) {
+    &((*c).p);
+}
+#[repr(C)]
+pub struct opaque {
+    _opaque: [u8; 0],
+}