[unsafe] Fix non-const global initializers and [unsafe, refcount] order of global initialization (#366)

Rust requires initializers of global variables to be const. C++ does not
require that.

To fix this tension, wrap global variables in `std::cell::LazyCell` so
that initialization does not depend on the constness of the initializer.

Another problem that this PR fixes is the moment when global variables
are initialized in both refcount and unsafe. `thread_local` in refcount
and the new `LazyCell` in unsafe initialize the variable on the first
usage. This is wrong if the constructors of the global variables have
side effects that must be visible in the program, for example:

```cpp
#include <cassert>

static int total = 0;

struct S {
  S(int x) { total += x; }
};

// there is no explicit usage of a and b inside the program other than the initialization
// however the constructor has side effects that are visible on the total variable
// so the initialization has to happen before entering main, not lazily as thread_local
// and LazyCell normally do
static S a(1);
static S b(10);

int main() {
  assert(total == 11);
  return 0;
}
```

To fix this, I added a new function that runs before main and forces the
initialization of global variables: `__cpp2rust_init_globals()`.

---------

Co-authored-by: Nuno Lopes <nuno.lopes@tecnico.ulisboa.pt>

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -26,6 +26,7 @@ namespace cpp2rust {
 std::unordered_map<std::string, std::string> Converter::inner_structs_;
 std::unordered_set<std::string> Converter::decl_ids_;
 std::unordered_set<std::string> Converter::globals_;
+std::vector<std::string> Converter::global_inits_;
 std::unordered_set<std::string> Converter::abstract_structs_;
 Converter::RecordIndex Converter::record_decls_;
 std::map<std::string, Converter::MethodsOnPtr> Converter::methods_on_ptr_;
@@ -59,8 +60,7 @@ use std::rc::Rc;
 )");
 }
 
-std::string Converter::EmitMethodsOnPtr() {
-  std::string out;
+void Converter::EmitMethodsOnPtr(std::string &out) {
   for (const auto &[name, methods] : methods_on_ptr_) {
     out += methods.trait_header;
     out += " {\n";
@@ -71,18 +71,30 @@ std::string Converter::EmitMethodsOnPtr() {
     out += methods.impl_body;
     out += "}\n";
   }
-  return out;
 }
 
-std::string Converter::EmitOpaqueRecords() {
-  std::string out;
+std::string Converter::ForceGlobalInit(const clang::VarDecl *decl) {
+  return std::format("std::cell::LazyCell::force(&*&raw const {});",
+                     GetNamedDeclAsString(decl));
+}
+
+void Converter::EmitGlobalInits(Model model, std::string &out) {
+  out += model == Model::kUnsafe ? "pub unsafe fn __cpp2rust_init_globals() {\n"
+                                 : "pub fn __cpp2rust_init_globals() {\n";
+  for (const auto &line : global_inits_) {
+    out += line;
+    out += '\n';
+  }
+  out += "}\n";
+}
+
+void Converter::EmitOpaqueRecords(std::string &out) {
   record_decls_.ForEachUndefined([&](const std::string &name) {
     out += "#[derive(Clone, Copy, Default, ByteRepr)]";
     out += "pub struct ";
     out += name;
     out += ";\n";
   });
-  return out;
 }
 
 bool Converter::VisitRecoveryExpr(clang::RecoveryExpr *expr) {
@@ -515,6 +527,7 @@ bool Converter::ConvertVarDeclSkipInit(clang::VarDecl *decl) {
     StrCat(AccessSpecifierAsString(decl->getAccess()), keyword::kStatic,
            keyword_mut_);
     ENSURE(decl_ids_.insert(GetID(decl)).second);
+    global_inits_.push_back(ForceGlobalInit(decl));
   } else if (decl->isStaticLocal()) {
     StrCat(keyword::kStatic, keyword_mut_);
   } else if (decl->isLocalVarDecl()) {
@@ -535,7 +548,10 @@ bool Converter::ConvertVarDeclSkipInit(clang::VarDecl *decl) {
   if (is_parm_with_default_value) {
     StrCat("Option<");
   }
-  Convert(qual_type);
+  {
+    PushLazyType lazy(*this, IsGlobalVar(decl) && LazyStaticInit());
+    Convert(qual_type);
+  }
   if (is_parm_with_default_value) {
     StrCat('>');
   }
@@ -600,8 +616,9 @@ void Converter::ConvertGlobalVarDecl(clang::VarDecl *decl) {
   PushConstInitializer static_init(*this, decl->isFileVarDecl() ||
                                               decl->isStaticLocal());
   StrCat(token::kAssign);
-  StrCat(keyword_unsafe_);
   {
+    PushLazyInit lazy(*this, LazyStaticInit());
+    StrCat(keyword_unsafe_);
     PushBrace push(*this);
     ConvertVarDeclInitializer(decl);
   }
@@ -2925,7 +2942,11 @@ std::string Converter::ConvertDeclRefExpr(clang::DeclRefExpr *expr) {
   }
 
   if (IsGlobalVar(expr)) {
-    return GetNamedDeclAsString(expr->getDecl());
+    if (LazyStaticInit()) {
+      return std::format("(*std::cell::LazyCell::force_mut(&mut *&raw mut {}))",
+                         GetNamedDeclAsString(decl));
+    }
+    return GetNamedDeclAsString(decl);
   }
 
   return GetNamedDeclAsString(decl);
@@ -4279,14 +4300,15 @@ pub fn main() {{
     let mut argv: Vec<*mut libc::c_char> = args.iter().map(|arg| arg.as_ptr() as *mut libc::c_char).collect();
     argv.push(::std::ptr::null_mut());
     unsafe {{
+        __cpp2rust_init_globals();
         ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32)
     }}
 }})",
                        main_function_name));
   } else {
-    StrCat(std::format(
-        "pub fn main() {{ unsafe {{ std::process::exit({}() as i32); }} }}",
-        main_function_name));
+    StrCat(std::format("pub fn main() {{ unsafe {{ __cpp2rust_init_globals(); "
+                       "std::process::exit({}() as i32); }} }}",
+                       main_function_name));
   }
 }
 

cpp2rust/converter/converter.h

@@ -18,6 +18,7 @@
 #include <vector>
 
 #include "converter/converter_lib.h"
+#include "converter/factory.h"
 #include "converter/lex.h"
 #include "converter/translation_rule.h"
 #include "logging.h"
@@ -51,9 +52,10 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitFilePreamble();
 
-  static std::string EmitOpaqueRecords();
+  static void EmitOpaqueRecords(std::string &out);
+  static void EmitGlobalInits(Model model, std::string &out);
 
-  static std::string EmitMethodsOnPtr();
+  static void EmitMethodsOnPtr(std::string &out);
 
   virtual bool VisitBuiltinType(clang::BuiltinType *type);
 
@@ -98,6 +100,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual bool VisitFunctionTemplateDecl(clang::FunctionTemplateDecl *decl);
 
   virtual bool VisitVarDecl(clang::VarDecl *decl);
+  virtual bool LazyStaticInit() const { return true; }
+  virtual std::string ForceGlobalInit(const clang::VarDecl *decl);
 
   void ConvertVarDecl(clang::VarDecl *decl);
 
@@ -481,7 +485,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
     std::string str() && { return std::move(partial_code); }
   };
 
-  template <char kOpen, char kClose> class PushDelim {
+  template <auto kOpen, auto kClose> class PushDelim {
     Converter &c;
     bool enabled;
 
@@ -506,6 +510,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
       PushDelim<token::kOpenCurlyBracket, token::kCloseCurlyBracket>;
   using PushParen = PushDelim<token::kOpenParen, token::kCloseParen>;
   using PushBracket = PushDelim<token::kOpenBracket, token::kCloseBracket>;
+  using PushLazyType = PushDelim<token::kLazyCellType, token::kGt>;
+  using PushLazyInit = PushDelim<token::kLazyCellNew, token::kCloseParen>;
 
   template <typename T>
   inline std::string
@@ -1038,6 +1044,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   std::vector<ExprKind> curr_expr_kind_;
   static std::unordered_map<std::string, std::string> inner_structs_;
   static std::unordered_set<std::string> globals_;
+  static std::vector<std::string> global_inits_;
   clang::Sema *sema_ = nullptr;
 };
 } // namespace cpp2rust

cpp2rust/converter/lex.h

@@ -30,6 +30,8 @@ inline constexpr char kDiv = '/';
 inline constexpr char kLt = '<';
 inline constexpr char kGt = '>';
 inline constexpr char kNewLine = '\n';
+inline constexpr const char kLazyCellType[] = "std::cell::LazyCell<";
+inline constexpr const char kLazyCellNew[] = "std::cell::LazyCell::new(||";
 } // namespace token
 
 namespace keyword {

cpp2rust/converter/models/converter_refcount.cpp

@@ -2448,6 +2448,10 @@ void ConverterRefCount::ConvertPointerSubscript(
   }
 }
 
+std::string ConverterRefCount::ForceGlobalInit(const clang::VarDecl *decl) {
+  return std::format("let _ = {}.with(|_| ());", GetNamedDeclAsString(decl));
+}
+
 void ConverterRefCount::ConvertFunctionMain(
     const clang::FunctionDecl *decl,
     const std::string_view main_function_name) {
@@ -2461,12 +2465,14 @@ pub fn main() {{
         argv.iter().map(|x| {{ x.borrow_mut().push(0); x.as_pointer() }}).collect(),
     ));
     (*argv.borrow_mut()).push(Ptr::null());
+    __cpp2rust_init_globals();
     ::std::process::exit({}(::std::env::args().len() as i32,
                                 argv.as_pointer()));
 }})",
                        main_function_name));
   } else {
-    StrCat(std::format("pub fn main() {{ std::process::exit({}()); }}",
+    StrCat(std::format("pub fn main() {{ __cpp2rust_init_globals(); "
+                       "std::process::exit({}()); }}",
                        main_function_name));
   }
 }

cpp2rust/converter/models/converter_refcount.h

@@ -79,6 +79,8 @@ class ConverterRefCount final : public Converter {
   void EmitFunctionPreamble(clang::FunctionDecl *decl) override;
 
   bool VisitVarDecl(clang::VarDecl *decl) override;
+  bool LazyStaticInit() const override { return false; }
+  std::string ForceGlobalInit(const clang::VarDecl *decl) override;
 
   void ConvertGlobalVarDecl(clang::VarDecl *decl) override;
 

cpp2rust/cpp2rust_lib.cpp

@@ -30,8 +30,9 @@ 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::EmitOpaqueRecords();
-  rs_code += Converter::EmitMethodsOnPtr();
+  Converter::EmitOpaqueRecords(rs_code);
+  Converter::EmitMethodsOnPtr(rs_code);
+  Converter::EmitGlobalInits(model, rs_code);
   return rs_code;
 }
 
@@ -71,8 +72,9 @@ 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::EmitOpaqueRecords();
-  rs_code += Converter::EmitMethodsOnPtr();
+  Converter::EmitOpaqueRecords(rs_code);
+  Converter::EmitMethodsOnPtr(rs_code);
+  Converter::EmitGlobalInits(model, rs_code);
   return rs_code;
 }
 } // namespace cpp2rust

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

@@ -14,6 +14,7 @@ pub fn a_value_1() -> i32 {
     return (*x.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ pub fn b_value_2() -> i32 {
     (*x.borrow_mut()) |= (anon_3_BETA as i32);
     return (*x.borrow());
 }
+pub fn __cpp2rust_init_globals() {}

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

@@ -15,6 +15,7 @@ pub unsafe fn a_value_1() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ pub unsafe fn b_value_2() -> i32 {
     x |= (anon_3_BETA as i32);
     return x;
 }
+pub unsafe fn __cpp2rust_init_globals() {}

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

@@ -36,6 +36,7 @@ pub fn a_value_0() -> i32 {
     return (*(*w.borrow()).id.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -51,3 +52,4 @@ pub fn b_value_1() -> i32 {
     let w: Value<widget_enum> = Rc::new(RefCell::new(widget_enum_WIDGET_C));
     return ((*w.borrow()) as i32);
 }
+pub fn __cpp2rust_init_globals() {}

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

@@ -18,6 +18,7 @@ pub unsafe fn a_value_0() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ pub unsafe fn b_value_1() -> i32 {
     let mut w: widget_enum = widget_enum_WIDGET_C;
     return (w as i32);
 }
+pub unsafe fn __cpp2rust_init_globals() {}