From e77de9d575321ea3b45347be28ffd62106cdb788 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Mon, 14 Sep 2026 14:33:39 +0100
Subject: [PATCH 1/9] Add test for global initialization with non-const
 expression

---
 tests/unit/global_non_const_init.cpp          |  79 +++++++
 .../out/refcount/global_non_const_init.rs     | 218 ++++++++++++++++++
 .../unit/out/unsafe/global_non_const_init.rs  | 115 +++++++++
 3 files changed, 412 insertions(+)
 create mode 100644 tests/unit/global_non_const_init.cpp
 create mode 100644 tests/unit/out/refcount/global_non_const_init.rs
 create mode 100644 tests/unit/out/unsafe/global_non_const_init.rs

diff --git a/tests/unit/global_non_const_init.cpp b/tests/unit/global_non_const_init.cpp
new file mode 100644
index 000000000..85a2a36a7
--- /dev/null
+++ b/tests/unit/global_non_const_init.cpp
@@ -0,0 +1,79 @@
+#include <cassert>
+#include <cstdint>
+#include <string>
+
+int next() {
+  static int counter = 0;
+  return ++counter;
+}
+
+// constexpr function call
+constexpr uint8_t marker(uint8_t tag) { return (tag << 3) | 2; }
+const uint8_t signature[3] = {marker(1), 0x04, 'B'};
+static uint8_t single = marker(2);
+
+// non-constexpr function call
+static int from_call = next();
+static int depends_on_call = from_call + 1;
+
+// constructors
+struct Ctor {
+  int v;
+  Ctor() : v(next()) {}
+  explicit Ctor(int x) : v(x) {}
+};
+static Ctor default_ctor;
+static Ctor arg_ctor(7);
+
+// std::string
+std::string str = "abc";
+
+// static data members
+struct Holder {
+  static int member;
+  static inline Ctor inline_member{5};
+};
+int Holder::member = next();
+
+// static locals
+int local_static() {
+  static int once = next();
+  static Ctor local_ctor(3);
+  return once + local_ctor.v;
+}
+
+// singleton via function local static
+struct Singleton {
+  int hits;
+  Singleton() : hits(0) {}
+  static Singleton &instance() {
+    static Singleton s;
+    return s;
+  }
+};
+
+int main() {
+  assert(signature[0] == 10);
+  assert(signature[1] == 0x04);
+  assert(single == 18);
+
+  assert(from_call == 1);
+  assert(depends_on_call == 2);
+
+  assert(default_ctor.v == 2);
+  assert(arg_ctor.v == 7);
+
+  assert(str == "abc");
+
+  assert(Holder::member == 3);
+  assert(Holder::inline_member.v == 5);
+
+  assert(local_static() == 7);
+  assert(local_static() == 7);
+
+  Singleton::instance().hits++;
+  Singleton::instance().hits++;
+  assert(Singleton::instance().hits == 2);
+  assert(&Singleton::instance() == &Singleton::instance());
+  return 0;
+}
diff --git a/tests/unit/out/refcount/global_non_const_init.rs b/tests/unit/out/refcount/global_non_const_init.rs
new file mode 100644
index 000000000..60f5f8566
--- /dev/null
+++ b/tests/unit/out/refcount/global_non_const_init.rs
@@ -0,0 +1,218 @@
+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};
+pub fn next_0() -> i32 {
+    thread_local!(
+        static counter_1: Value<i32> = Rc::new(RefCell::new(0));
+    );
+    return (*counter_1.with(Value::clone).borrow_mut()).prefix_inc();
+}
+pub fn marker_2(tag: u8) -> u8 {
+    let tag: Value<u8> = Rc::new(RefCell::new(tag));
+    return (((((*tag.borrow()) as i32) << 3) | 2) as u8);
+}
+thread_local!(
+    pub static signature_3: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::new([
+        ({ marker_2(1_u8) }),
+        4_u8,
+        ('B' as u8),
+    ])));
+);
+thread_local!(
+    pub static single_4: Value<u8> = Rc::new(RefCell::new(({ marker_2(2_u8) })));
+);
+thread_local!(
+    pub static from_call_5: Value<i32> = Rc::new(RefCell::new(({ next_0() })));
+);
+thread_local!(
+    pub static depends_on_call_6: Value<i32> = Rc::new(RefCell::new(
+        ((*from_call_5.with(Value::clone).borrow()) + 1),
+    ));
+);
+#[derive()]
+pub struct Ctor {
+    pub v: Value<i32>,
+}
+impl Ctor {
+    pub fn Ctor1() -> Self {
+        let __this: Value<Ctor> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new(({ next_0() }))),
+        }));
+        let this: Ptr<Ctor> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+    pub fn Ctor2(x: i32) -> Self {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        let __this: Value<Ctor> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*x.borrow()))),
+        }));
+        let this: Ptr<Ctor> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Clone for Ctor {
+    fn clone(&self) -> Self {
+        let __this: Value<Ctor> = Rc::new(RefCell::new(Self {
+            v: Rc::new(RefCell::new((*self.v.borrow()))),
+        }));
+        let this: Ptr<Ctor> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Default for Ctor {
+    fn default() -> Self {
+        { Ctor::Ctor1() }
+    }
+}
+impl ByteRepr for Ctor {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.v.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            v: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+thread_local!(
+    pub static default_ctor_7: Value<Ctor> = Rc::new(RefCell::new(Ctor::Ctor1()));
+);
+thread_local!(
+    pub static arg_ctor_8: Value<Ctor> = Rc::new(RefCell::new(Ctor::Ctor2({ 7 })));
+);
+thread_local!(
+    pub static str_9: Value<Vec<u8>> = Rc::new(RefCell::new(
+        Ptr::from_string_literal(b"abc")
+            .to_c_string_iterator()
+            .chain(std::iter::once(0))
+            .collect::<Vec<u8>>(),
+    ));
+);
+thread_local!();
+thread_local!(
+    pub static inline_member_11: Value<Ctor> = Rc::new(RefCell::new(Ctor::Ctor2({ 5 })));
+);
+#[derive(Default)]
+pub struct Holder {}
+impl Clone for Holder {
+    fn clone(&self) -> Self {
+        let __this: Value<Holder> = Rc::new(RefCell::new(Self {}));
+        let this: Ptr<Holder> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for Holder {
+    fn byte_size() -> usize {
+        1
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {}
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {}
+    }
+}
+thread_local!(
+    pub static member_10: Value<i32> = Rc::new(RefCell::new(({ next_0() })));
+);
+pub fn local_static_12() -> i32 {
+    thread_local!(
+        static once_13: Value<i32> = Rc::new(RefCell::new(({ next_0() })));
+    );
+    thread_local!(
+        static local_ctor_14: Value<Ctor> = Rc::new(RefCell::new(Ctor::Ctor2({ 3 })));
+    );
+    return ((*once_13.with(Value::clone).borrow())
+        + (*(*local_ctor_14.with(Value::clone).borrow()).v.borrow()));
+}
+#[derive()]
+pub struct Singleton {
+    pub hits: Value<i32>,
+}
+impl Singleton {
+    pub fn Singleton() -> Self {
+        let __this: Value<Singleton> = Rc::new(RefCell::new(Self {
+            hits: Rc::new(RefCell::new(0)),
+        }));
+        let this: Ptr<Singleton> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+    pub fn instance() -> Ptr<Singleton> {
+        thread_local!(
+            static s_15: Value<Singleton> = Rc::new(RefCell::new(Singleton::Singleton()));
+        );
+        return s_15.with(Value::clone).as_pointer();
+    }
+}
+impl Clone for Singleton {
+    fn clone(&self) -> Self {
+        let __this: Value<Singleton> = Rc::new(RefCell::new(Self {
+            hits: Rc::new(RefCell::new((*self.hits.borrow()))),
+        }));
+        let this: Ptr<Singleton> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Default for Singleton {
+    fn default() -> Self {
+        { Singleton::Singleton() }
+    }
+}
+impl ByteRepr for Singleton {
+    fn byte_size() -> usize {
+        4
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {
+        (*self.hits.borrow()).to_bytes(&mut buf[0..4]);
+    }
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {
+            hits: Rc::new(RefCell::new(<i32>::from_bytes(&buf[0..4]))),
+        }
+    }
+}
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!((((*signature_3.with(Value::clone).borrow())[(0) as usize] as i32) == 10));
+    assert!((((*signature_3.with(Value::clone).borrow())[(1) as usize] as i32) == 4));
+    assert!((((*single_4.with(Value::clone).borrow()) as i32) == 18));
+    assert!(((*from_call_5.with(Value::clone).borrow()) == 1));
+    assert!(((*depends_on_call_6.with(Value::clone).borrow()) == 2));
+    assert!(((*(*default_ctor_7.with(Value::clone).borrow()).v.borrow()) == 2));
+    assert!(((*(*arg_ctor_8.with(Value::clone).borrow()).v.borrow()) == 7));
+    assert!(
+        (*str_9.with(Value::clone).borrow())
+            .iter()
+            .copied()
+            .take((*str_9.with(Value::clone).borrow()).len().saturating_sub(1))
+            .eq(Ptr::from_string_literal(b"abc").to_c_string_iterator())
+    );
+    assert!(((*member_10.with(Value::clone).borrow()) == 3));
+    assert!(((*(*inline_member_11.with(Value::clone).borrow()).v.borrow()) == 5));
+    assert!((({ local_static_12() }) == 7));
+    assert!((({ local_static_12() }) == 7));
+    (*(*({ Singleton::instance() }).upgrade().deref())
+        .hits
+        .borrow_mut())
+    .postfix_inc();
+    (*(*({ Singleton::instance() }).upgrade().deref())
+        .hits
+        .borrow_mut())
+    .postfix_inc();
+    assert!(
+        ((*(*({ Singleton::instance() }).upgrade().deref())
+            .hits
+            .borrow())
+            == 2)
+    );
+    assert!((({ Singleton::instance() }) == ({ Singleton::instance() })));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/global_non_const_init.rs b/tests/unit/out/unsafe/global_non_const_init.rs
new file mode 100644
index 000000000..44b18d185
--- /dev/null
+++ b/tests/unit/out/unsafe/global_non_const_init.rs
@@ -0,0 +1,115 @@
+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;
+pub unsafe fn next_0() -> i32 {
+    static mut counter_1: i32 = unsafe { 0 };;
+    return counter_1.prefix_inc();
+}
+pub unsafe fn marker_2(mut tag: u8) -> u8 {
+    return ((((tag as i32) << (3)) | (2)) as u8);
+}
+pub static mut signature_3: [u8; 3] = unsafe {
+    [
+        (unsafe { marker_2(1_u8) }),
+        4_u8,
+        (('B' as libc::c_char) as u8),
+    ]
+};
+pub static mut single_4: u8 = unsafe { (unsafe { marker_2(2_u8) }) };
+pub static mut from_call_5: i32 = unsafe { (unsafe { next_0() }) };
+pub static mut depends_on_call_6: i32 = unsafe { ((from_call_5) + (1)) };
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Ctor {
+    pub v: i32,
+}
+impl Ctor {
+    pub unsafe fn Ctor1() -> Self {
+        let mut this = Self {
+            v: (unsafe { next_0() }),
+        };
+        this
+    }
+    pub unsafe fn Ctor2(mut x: i32) -> Self {
+        let mut this = Self { v: x };
+        this
+    }
+}
+impl Default for Ctor {
+    fn default() -> Self {
+        unsafe { Ctor::Ctor1() }
+    }
+}
+pub static mut default_ctor_7: Ctor = unsafe { Ctor::Ctor1() };
+pub static mut arg_ctor_8: Ctor = unsafe { Ctor::Ctor2({ 7 }) };
+pub static mut str_9: Vec<libc::c_char> = unsafe {
+    {
+        let s = c"abc".as_ptr();
+        std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
+    }
+};
+pub static mut inline_member_11: Ctor = unsafe { Ctor::Ctor2({ 5 }) };
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct Holder {}
+pub static mut member_10: i32 = unsafe { (unsafe { next_0() }) };
+pub unsafe fn local_static_12() -> i32 {
+    static mut once_13: i32 = unsafe { (unsafe { next_0() }) };;
+    static mut local_ctor_14: Ctor = unsafe { Ctor::Ctor2({ 3 }) };;
+    return ((once_13) + (local_ctor_14.v));
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Singleton {
+    pub hits: i32,
+}
+impl Singleton {
+    pub unsafe fn Singleton() -> Self {
+        let mut this = Self { hits: 0 };
+        this
+    }
+    pub unsafe fn instance() -> *mut Singleton {
+        static mut s_15: Singleton = unsafe { Singleton::Singleton() };;
+        return &mut s_15 as *mut Singleton;
+    }
+}
+impl Default for Singleton {
+    fn default() -> Self {
+        unsafe { Singleton::Singleton() }
+    }
+}
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    assert!(((signature_3[(0) as usize] as i32) == (10)));
+    assert!(((signature_3[(1) as usize] as i32) == (4)));
+    assert!(((single_4 as i32) == (18)));
+    assert!(((from_call_5) == (1)));
+    assert!(((depends_on_call_6) == (2)));
+    assert!(((default_ctor_7.v) == (2)));
+    assert!(((arg_ctor_8.v) == (7)));
+    assert!(
+        str_9 == {
+            let s = c"abc".as_ptr();
+            std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
+                .to_vec()
+        }
+    );
+    assert!(((member_10) == (3)));
+    assert!(((inline_member_11.v) == (5)));
+    assert!(((unsafe { local_static_12() }) == (7)));
+    assert!(((unsafe { local_static_12() }) == (7)));
+    (*(unsafe { Singleton::instance() })).hits.postfix_inc();
+    (*(unsafe { Singleton::instance() })).hits.postfix_inc();
+    assert!((((*(unsafe { Singleton::instance() })).hits) == (2)));
+    assert!(((unsafe { Singleton::instance() }) == (unsafe { Singleton::instance() })));
+    return 0;
+}

From ea704563e3273cb809f500934e87da7e1a170069 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Mon, 14 Sep 2026 14:51:46 +0100
Subject: [PATCH 2/9] Update tests

---
 .../out/unsafe/static_name_collision.rs       |  20 +--
 tests/unit/out/unsafe/addr_of_global.rs       |  59 +++++---
 tests/unit/out/unsafe/array_const_init.rs     |  18 ++-
 .../unit/out/unsafe/bool_condition_logical.rs |  10 +-
 .../out/unsafe/bool_condition_logical_c.rs    |  14 +-
 tests/unit/out/unsafe/constructor.rs          |  12 +-
 tests/unit/out/unsafe/copy_assign.rs          |  16 +--
 tests/unit/out/unsafe/copy_ctor.rs            |  18 +--
 tests/unit/out/unsafe/default_in_statics.rs   | 134 +++++++++++-------
 tests/unit/out/unsafe/destructor.rs           |  50 ++++---
 .../out/unsafe/enum_comparisson_in_globals.rs |   5 +-
 .../unit/out/unsafe/enum_default_in_static.rs |  14 +-
 tests/unit/out/unsafe/enum_int_interop.rs     |  58 ++++++--
 tests/unit/out/unsafe/enum_int_interop_c.rs   |  67 ++++++---
 tests/unit/out/unsafe/fn_ptr_global.rs        |  17 +--
 tests/unit/out/unsafe/fn_ptr_vtable.rs        |   9 +-
 .../global-initialization-using-global.rs     |  13 +-
 .../unit/out/unsafe/global_non_const_init.rs  |  84 ++++++-----
 tests/unit/out/unsafe/global_pointers.rs      |  34 +++--
 .../out/unsafe/global_without_initializer.rs  |  14 +-
 tests/unit/out/unsafe/null_in_statics.rs      |  46 +++---
 .../unsafe/operator_member_pointer_member.rs  |   8 +-
 tests/unit/out/unsafe/rule_of_five.rs         |  53 ++++---
 tests/unit/out/unsafe/rule_of_three.rs        |  35 +++--
 tests/unit/out/unsafe/rvalue_ref_global.rs    |   5 +-
 .../unsafe/static_function_vars_same_name.rs  |   8 +-
 tests/unit/out/unsafe/static_local.rs         |  18 ++-
 tests/unit/out/unsafe/static_shadow.rs        |   4 +-
 tests/unit/out/unsafe/static_var_in_class.rs  |   8 +-
 tests/unit/out/unsafe/string_escape.rs        |  97 +++++++------
 .../unsafe/string_literal_interior_null.rs    |  24 ++--
 .../out/unsafe/string_literal_ptr_init.rs     |  51 +++++--
 .../out/unsafe/union_tagged_struct_arms.rs    |  17 +--
 tests/unit/out/unsafe/void_cast.rs            |  17 +--
 34 files changed, 656 insertions(+), 401 deletions(-)

diff --git a/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs b/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs
index f66ac5ea3..88cd3770a 100644
--- a/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs
+++ b/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs
@@ -6,13 +6,15 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut same_name_different_type_0: i32 = unsafe { 1 };
-pub static mut same_name_same_type_1: i32 = unsafe { 5 };
+pub static mut same_name_different_type_0: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { 1 });
+pub static mut same_name_same_type_1: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { 5 });
 pub unsafe fn a_foo_2() -> i32 {
-    return same_name_different_type_0;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut same_name_different_type_0));
 }
 pub unsafe fn a_bar_3() -> i32 {
-    return same_name_same_type_1;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut same_name_same_type_1));
 }
 pub fn main() {
     unsafe {
@@ -26,11 +28,13 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { b_bar_5() }) == (6)) as i32) != 0));
     return 0;
 }
-pub static mut same_name_different_type_6: f32 = unsafe { 1.0E+0 };
-pub static mut same_name_same_type_7: i32 = unsafe { 6 };
+pub static mut same_name_different_type_6: std::cell::LazyCell<f32> =
+    std::cell::LazyCell::new(|| unsafe { 1.0E+0 });
+pub static mut same_name_same_type_7: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { 6 });
 pub unsafe fn b_foo_4() -> f32 {
-    return same_name_different_type_6;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut same_name_different_type_6));
 }
 pub unsafe fn b_bar_5() -> i32 {
-    return same_name_same_type_7;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut same_name_same_type_7));
 }
diff --git a/tests/unit/out/unsafe/addr_of_global.rs b/tests/unit/out/unsafe/addr_of_global.rs
index 496ef09dd..8b56bca96 100644
--- a/tests/unit/out/unsafe/addr_of_global.rs
+++ b/tests/unit/out/unsafe/addr_of_global.rs
@@ -16,36 +16,49 @@ pub struct Inner {
 pub struct Outer {
     pub p: *mut Inner,
 }
-pub static mut alpha_0: Inner = unsafe { Inner { value: 1 } };
-pub static mut beta_1: Inner = unsafe { Inner { value: 2 } };
-pub static mut shared_2: Inner = unsafe { Inner { value: 42 } };
-pub static mut items_3: [*mut Inner; 2] = unsafe {
-    [
-        (&raw mut alpha_0 as *mut Inner),
-        (&raw mut beta_1 as *mut Inner),
-    ]
-};
-pub static mut obj_4: Outer = unsafe {
+pub static mut alpha_0: std::cell::LazyCell<Inner> =
+    std::cell::LazyCell::new(|| unsafe { Inner { value: 1 } });
+pub static mut beta_1: std::cell::LazyCell<Inner> =
+    std::cell::LazyCell::new(|| unsafe { Inner { value: 2 } });
+pub static mut shared_2: std::cell::LazyCell<Inner> =
+    std::cell::LazyCell::new(|| unsafe { Inner { value: 42 } });
+pub static mut items_3: std::cell::LazyCell<[*mut Inner; 2]> =
+    std::cell::LazyCell::new(|| unsafe {
+        [
+            (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut alpha_0)) as *mut Inner),
+            (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut beta_1)) as *mut Inner),
+        ]
+    });
+pub static mut obj_4: std::cell::LazyCell<Outer> = std::cell::LazyCell::new(|| unsafe {
     Outer {
-        p: (&raw mut shared_2 as *mut Inner),
+        p: (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut shared_2)) as *mut Inner),
     }
-};
+});
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!((((*items_3[(0) as usize]).value) == (1)));
-    assert!((((*items_3[(1) as usize]).value) == (2)));
-    assert!((((*obj_4.p).value) == (42)));
-    static mut cache_5: [*mut Inner; 2] = unsafe {
-        [
-            (&raw mut alpha_0 as *mut Inner),
-            (&raw mut beta_1 as *mut Inner),
-        ]
-    };;
-    assert!((((*cache_5[(0) as usize]).value) == (1)));
-    assert!((((*cache_5[(1) as usize]).value) == (2)));
+    assert!(
+        (((*(*std::cell::LazyCell::force_mut(&mut *&raw mut items_3))[(0) as usize]).value) == (1))
+    );
+    assert!(
+        (((*(*std::cell::LazyCell::force_mut(&mut *&raw mut items_3))[(1) as usize]).value) == (2))
+    );
+    assert!((((*(*std::cell::LazyCell::force_mut(&mut *&raw mut obj_4)).p).value) == (42)));
+    static mut cache_5: std::cell::LazyCell<[*mut Inner; 2]> =
+        std::cell::LazyCell::new(|| unsafe {
+            [
+                (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut alpha_0)) as *mut Inner),
+                (&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut beta_1)) as *mut Inner),
+            ]
+        });;
+    assert!(
+        (((*(*std::cell::LazyCell::force_mut(&mut *&raw mut cache_5))[(0) as usize]).value) == (1))
+    );
+    assert!(
+        (((*(*std::cell::LazyCell::force_mut(&mut *&raw mut cache_5))[(1) as usize]).value) == (2))
+    );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/array_const_init.rs b/tests/unit/out/unsafe/array_const_init.rs
index 7601a660b..ed58820bd 100644
--- a/tests/unit/out/unsafe/array_const_init.rs
+++ b/tests/unit/out/unsafe/array_const_init.rs
@@ -22,28 +22,36 @@ impl Default for S {
         }
     }
 }
-pub static mut s_0: S = unsafe {
+pub static mut s_0: std::cell::LazyCell<S> = std::cell::LazyCell::new(|| unsafe {
     S {
         head: 5,
         tail: [0; 3],
         buf: [0; 4],
     }
-};
+});
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((((s_0.head) == (5)) as i32) != 0));
+    assert!((((((*std::cell::LazyCell::force_mut(&mut *&raw mut s_0)).head) == (5)) as i32) != 0));
     let mut i: i32 = 0;
     'loop_: while ((((i) < (3)) as i32) != 0) {
-        assert!(((((s_0.tail[(i) as usize]) == (0)) as i32) != 0));
+        assert!(
+            (((((*std::cell::LazyCell::force_mut(&mut *&raw mut s_0)).tail[(i) as usize]) == (0))
+                as i32)
+                != 0)
+        );
         i.postfix_inc();
     }
     let mut i: i32 = 0;
     'loop_: while ((((i) < (4)) as i32) != 0) {
-        assert!(((((s_0.buf[(i) as usize] as i32) == (0)) as i32) != 0));
+        assert!(
+            (((((*std::cell::LazyCell::force_mut(&mut *&raw mut s_0)).buf[(i) as usize] as i32)
+                == (0)) as i32)
+                != 0)
+        );
         i.postfix_inc();
     }
     return 0;
diff --git a/tests/unit/out/unsafe/bool_condition_logical.rs b/tests/unit/out/unsafe/bool_condition_logical.rs
index 36ab7f233..a86aeab4f 100644
--- a/tests/unit/out/unsafe/bool_condition_logical.rs
+++ b/tests/unit/out/unsafe/bool_condition_logical.rs
@@ -10,9 +10,9 @@ pub type Code = u32;
 pub const Code_CODE_OK: Code = 0;
 pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
-pub static mut side_effect_0: i32 = unsafe { 0 };
+pub static mut side_effect_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 pub unsafe fn observe_1(mut v: i32) -> i32 {
-    side_effect_0.prefix_inc();
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)).prefix_inc();
     return v;
 }
 pub unsafe fn returns_one_2() -> i32 {
@@ -49,15 +49,15 @@ unsafe fn main_0() -> i32 {
     if (((n != 0) && (u != 0)) && (!(p).is_null())) && ((code as i32) == (Code_CODE_OK as i32)) {
         assert!(true);
     }
-    side_effect_0 = 0;
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)) = 0;
     if (zero != 0) && ((unsafe { observe_1(1) }) != 0) {
         assert!(false);
     }
-    assert!(((side_effect_0) == (0)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)) == (0)));
     if (n != 0) || ((unsafe { observe_1(1) }) != 0) {
         assert!(true);
     }
-    assert!(((side_effect_0) == (0)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)) == (0)));
     let mut x: i32 = 5;
     let mut y: i32 = 3;
     let mut flags: u32 = 2_u32;
diff --git a/tests/unit/out/unsafe/bool_condition_logical_c.rs b/tests/unit/out/unsafe/bool_condition_logical_c.rs
index f79c7dd9c..b7c287f6d 100644
--- a/tests/unit/out/unsafe/bool_condition_logical_c.rs
+++ b/tests/unit/out/unsafe/bool_condition_logical_c.rs
@@ -10,9 +10,9 @@ pub type Code = u32;
 pub const Code_CODE_OK: Code = 0;
 pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
-pub static mut side_effect_0: i32 = unsafe { 0 };
+pub static mut side_effect_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 pub unsafe fn observe_1(mut v: i32) -> i32 {
-    side_effect_0.prefix_inc();
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)).prefix_inc();
     return v;
 }
 pub unsafe fn returns_one_2() -> i32 {
@@ -52,15 +52,19 @@ unsafe fn main_0() -> i32 {
     {
         assert!((1 != 0));
     }
-    side_effect_0 = 0;
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)) = 0;
     if ((((zero != 0) && ((unsafe { observe_1(1) }) != 0)) as i32) != 0) {
         assert!((0 != 0));
     }
-    assert!(((((side_effect_0) == (0)) as i32) != 0));
+    assert!(
+        ((((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)) == (0)) as i32) != 0)
+    );
     if ((((n != 0) || ((unsafe { observe_1(1) }) != 0)) as i32) != 0) {
         assert!((1 != 0));
     }
-    assert!(((((side_effect_0) == (0)) as i32) != 0));
+    assert!(
+        ((((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_0)) == (0)) as i32) != 0)
+    );
     let mut x: i32 = 5;
     let mut y: i32 = 3;
     let mut flags: u32 = 2_u32;
diff --git a/tests/unit/out/unsafe/constructor.rs b/tests/unit/out/unsafe/constructor.rs
index 558fd5eb6..630023ec6 100644
--- a/tests/unit/out/unsafe/constructor.rs
+++ b/tests/unit/out/unsafe/constructor.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut total_0: i32 = unsafe { 0 };
+pub static mut total_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(Clone, Default)]
 pub struct S {
@@ -22,12 +22,14 @@ impl S {
     pub unsafe fn S(mut init: i32) -> Self {
         let mut this = Self { v: init };
         (unsafe { S::mut_method(&mut this) });
-        total_0 += (unsafe { S::const_method(&mut this) });
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) +=
+            (unsafe { S::const_method(&mut this) });
         this
     }
     pub unsafe fn destructor(&mut self) {
         (unsafe { S::mut_method(self) });
-        total_0 += (unsafe { S::const_method(self) });
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) +=
+            (unsafe { S::const_method(self) });
     }
 }
 pub fn main() {
@@ -40,8 +42,8 @@ unsafe fn main_0() -> i32 {
         let mut s: S = S::S({ 3 });
         let _dtor_s = ScopedDestructorUnsafe::new(&raw mut s, S::destructor);
         assert!(((s.v) == (4)));
-        assert!(((total_0) == (8)));
+        assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) == (8)));
     }
-    assert!(((total_0) == (18)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) == (18)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/copy_assign.rs b/tests/unit/out/unsafe/copy_assign.rs
index c16d17a50..12b506b83 100644
--- a/tests/unit/out/unsafe/copy_assign.rs
+++ b/tests/unit/out/unsafe/copy_assign.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut assigns_0: i32 = unsafe { 0 };
+pub static mut assigns_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(Default)]
 pub struct Partial {
@@ -30,7 +30,7 @@ impl Partial {
             return &mut (*(self as *mut Partial)) as *mut Partial;
         }
         self.v = (*o).v;
-        assigns_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)).prefix_inc();
         return &mut (*(self as *mut Partial)) as *mut Partial;
     }
 }
@@ -114,7 +114,7 @@ unsafe fn main_0() -> i32 {
     let mut c: Partial = Partial::Partial({ 3 }, { 300 });
     (unsafe { Partial::operator_assign(&mut a, &b as *const Partial) });
     assert!(((a.v) == (2)) && ((a.keep) == (100)));
-    assert!(((assigns_0) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (1)));
     (unsafe {
         Partial::operator_assign(
             &mut c,
@@ -123,18 +123,18 @@ unsafe fn main_0() -> i32 {
         )
     });
     assert!(((c.v) == (2)) && ((c.keep) == (300)));
-    assert!(((assigns_0) == (3)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (3)));
     (unsafe {
         let _o: *const Partial = &a as *const Partial;
         Partial::operator_assign(&mut a, _o)
     });
-    assert!(((assigns_0) == (3)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (3)));
     (unsafe {
         let mut _o: Partial = Partial::Partial({ 9 }, { 900 });
         Partial::operator_assign(&mut a, &mut _o)
     });
     assert!(((a.v) == (9)) && ((a.keep) == (100)));
-    assert!(((assigns_0) == (4)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (4)));
     let ra: *mut Partial = &mut a as *mut Partial;
     (unsafe {
         let _o: *const Partial = &c as *const Partial;
@@ -147,7 +147,7 @@ unsafe fn main_0() -> i32 {
         Partial::operator_assign(&mut (*pa), _o)
     });
     assert!(((a.v) == (2)));
-    assert!(((assigns_0) == (6)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (6)));
     let mut h: Holder = Holder {
         p: Partial::Partial({ 4 }, { 40 }),
         arr: [
@@ -159,7 +159,7 @@ unsafe fn main_0() -> i32 {
     (unsafe { Partial::operator_assign(&mut h.arr[(1) as usize], &c as *const Partial) });
     assert!(((h.p.v) == (2)) && ((h.p.keep) == (40)));
     assert!(((h.arr[(1) as usize].v) == (2)) && ((h.arr[(1) as usize].keep) == (60)));
-    assert!(((assigns_0) == (8)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (8)));
     let mut n: NonConstAssign = NonConstAssign::NonConstAssign();
     let mut n1: NonConstAssign = NonConstAssign::NonConstAssign();
     let mut n2: NonConstAssign = NonConstAssign::NonConstAssign();
diff --git a/tests/unit/out/unsafe/copy_ctor.rs b/tests/unit/out/unsafe/copy_ctor.rs
index 5bbe7906c..23da88110 100644
--- a/tests/unit/out/unsafe/copy_ctor.rs
+++ b/tests/unit/out/unsafe/copy_ctor.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut copies_0: i32 = unsafe { 0 };
+pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(Default)]
 pub struct Counted {
@@ -19,7 +19,7 @@ impl Counted {
     }
     pub unsafe fn Counted_pconstCounted(o: *const Counted) -> Self {
         let mut this = Self { v: (*o).v };
-        copies_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)).prefix_inc();
         this
     }
 }
@@ -92,23 +92,23 @@ unsafe fn main_0() -> i32 {
     let mut b: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
     let mut c: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
     let mut d: Counted = Counted::Counted_pconstCounted({ &a as *const Counted });
-    assert!(((copies_0) == (3)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (3)));
     assert!((((b.v) == (1)) && ((c.v) == (1))) && ((d.v) == (1)));
     assert!(
         ((unsafe { by_value_1(Counted::Counted_pconstCounted({ &a as *const Counted },),) })
             == (1))
     );
-    assert!(((copies_0) == (4)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (4)));
     let mut e: Counted = (unsafe { make_2(5) });
     assert!(((e.v) == (5)));
-    assert!(((copies_0) == (5)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (5)));
     let mut f: Counted = Counted::Counted({ 6 });
     assert!(((f.v) == (6)));
-    assert!(((copies_0) == (5)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (5)));
     let g: Counted = Counted::Counted({ 7 });
     let mut h: Counted = Counted::Counted_pconstCounted({ &g as *const Counted });
     assert!(((h.v) == (7)));
-    assert!(((copies_0) == (6)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (6)));
     let mut hold: Holder = Holder {
         c: Counted::Counted({ 8 }),
         arr: [Counted::Counted({ 9 }), Counted::Counted({ 10 })],
@@ -118,14 +118,14 @@ unsafe fn main_0() -> i32 {
         (((hold2.c.v) == (8)) && ((hold2.arr[(0) as usize].v) == (9)))
             && ((hold2.arr[(1) as usize].v) == (10))
     );
-    assert!(((copies_0) == (9)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (9)));
     let mut vec_: Vec<Counted> = Vec::new();
     {
         let a0_clone = a.clone();
         vec_.push(a0_clone)
     };
     assert!(((vec_[(0_usize)].v) == (1)));
-    assert!(((copies_0) == (10)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (10)));
     let mut n: NonConst = NonConst::NonConst();
     let mut n1: NonConst = NonConst::NonConst_pmutNonConst({ &mut n as *mut NonConst });
     let cn: NonConst = NonConst::NonConst();
diff --git a/tests/unit/out/unsafe/default_in_statics.rs b/tests/unit/out/unsafe/default_in_statics.rs
index 3ef0e18b5..d522fa046 100644
--- a/tests/unit/out/unsafe/default_in_statics.rs
+++ b/tests/unit/out/unsafe/default_in_statics.rs
@@ -58,8 +58,9 @@ impl Default for Foo {
         }
     }
 }
-pub static mut static_fn_0: Option<unsafe fn(i32) -> i32> = unsafe { None };
-pub static mut static_outer_1: Outer = unsafe {
+pub static mut static_fn_0: std::cell::LazyCell<Option<unsafe fn(i32) -> i32>> =
+    std::cell::LazyCell::new(|| unsafe { None });
+pub static mut static_outer_1: std::cell::LazyCell<Outer> = std::cell::LazyCell::new(|| unsafe {
     Outer {
         p1: std::ptr::null_mut(),
         p2: std::ptr::null(),
@@ -73,14 +74,15 @@ pub static mut static_outer_1: Outer = unsafe {
         x: 0_i32,
         fn_: None,
     }
-};
-pub static mut static_inner_array_2: [Inner; 2] = unsafe {
-    [Inner {
-        v: 0_i32,
-        name: std::ptr::null(),
-    }; 2]
-};
-pub static mut static_foo_3: Foo = unsafe {
+});
+pub static mut static_inner_array_2: std::cell::LazyCell<[Inner; 2]> =
+    std::cell::LazyCell::new(|| unsafe {
+        [Inner {
+            v: 0_i32,
+            name: std::ptr::null(),
+        }; 2]
+    });
+pub static mut static_foo_3: std::cell::LazyCell<Foo> = std::cell::LazyCell::new(|| unsafe {
     Foo {
         s1: c"hello".as_ptr(),
         s2: std::ptr::null(),
@@ -88,27 +90,28 @@ pub static mut static_foo_3: Foo = unsafe {
         fn2: None,
         n: 42,
     }
-};
-pub static mut static_foo_array_4: [Foo; 2] = unsafe {
-    [
-        Foo {
-            s1: c"first".as_ptr(),
-            s2: std::ptr::null(),
-            fn1: None,
-            fn2: None,
-            n: 1,
-        },
-        Foo {
-            s1: c"second".as_ptr(),
-            s2: std::ptr::null(),
-            fn1: None,
-            fn2: None,
-            n: 2,
-        },
-    ]
-};
+});
+pub static mut static_foo_array_4: std::cell::LazyCell<[Foo; 2]> =
+    std::cell::LazyCell::new(|| unsafe {
+        [
+            Foo {
+                s1: c"first".as_ptr(),
+                s2: std::ptr::null(),
+                fn1: None,
+                fn2: None,
+                n: 1,
+            },
+            Foo {
+                s1: c"second".as_ptr(),
+                s2: std::ptr::null(),
+                fn1: None,
+                fn2: None,
+                n: 2,
+            },
+        ]
+    });
 pub unsafe fn check_local_static_5() {
-    static mut local_outer_6: Outer = unsafe {
+    static mut local_outer_6: std::cell::LazyCell<Outer> = std::cell::LazyCell::new(|| unsafe {
         Outer {
             p1: std::ptr::null_mut(),
             p2: std::ptr::null(),
@@ -122,13 +125,15 @@ pub unsafe fn check_local_static_5() {
             x: 0_i32,
             fn_: None,
         }
-    };;
-    static mut local_fn_7: Option<unsafe fn(i32) -> i32> = unsafe { None };;
-    static mut local_p_8: *mut i32 = unsafe { std::ptr::null_mut() };;
-    assert!((local_outer_6.p1).is_null());
-    assert!((local_outer_6.fn_).is_none());
-    assert!((local_fn_7).is_none());
-    assert!((local_p_8).is_null());
+    });;
+    static mut local_fn_7: std::cell::LazyCell<Option<unsafe fn(i32) -> i32>> =
+        std::cell::LazyCell::new(|| unsafe { None });;
+    static mut local_p_8: std::cell::LazyCell<*mut i32> =
+        std::cell::LazyCell::new(|| unsafe { std::ptr::null_mut() });;
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut local_outer_6)).p1).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut local_outer_6)).fn_).is_none());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut local_fn_7)).is_none());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut local_p_8)).is_null());
 }
 pub fn main() {
     unsafe {
@@ -136,32 +141,55 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!((static_fn_0).is_none());
-    assert!((static_outer_1.p1).is_null());
-    assert!((static_outer_1.p2).is_null());
-    assert!((static_outer_1.cp).is_null());
-    assert!((static_outer_1.pp).is_null());
-    assert!((static_outer_1.fn_).is_none());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut static_fn_0)).is_none());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_outer_1)).p1).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_outer_1)).p2).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_outer_1)).cp).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_outer_1)).pp).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_outer_1)).fn_).is_none());
     let mut i: i32 = 0;
     'loop_: while ((i) < (3)) {
-        assert!((static_outer_1.arr[(i) as usize]).is_null());
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_outer_1)).arr[(i) as usize])
+                .is_null()
+        );
         i.prefix_inc();
     }
-    assert!((static_outer_1.inner.name).is_null());
+    assert!(
+        ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_outer_1))
+            .inner
+            .name)
+            .is_null()
+    );
     let mut i: i32 = 0;
     'loop_: while ((i) < (2)) {
-        assert!((static_inner_array_2[(i) as usize].name).is_null());
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_inner_array_2))[(i) as usize]
+                .name)
+                .is_null()
+        );
         i.prefix_inc();
     }
-    assert!((static_foo_3.s2).is_null());
-    assert!((static_foo_3.fn1).is_none());
-    assert!((static_foo_3.fn2).is_none());
-    assert!(((static_foo_3.n) == (42)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_foo_3)).s2).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_foo_3)).fn1).is_none());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut static_foo_3)).fn2).is_none());
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut static_foo_3)).n) == (42)));
     let mut i: i32 = 0;
     'loop_: while ((i) < (2)) {
-        assert!((static_foo_array_4[(i) as usize].s2).is_null());
-        assert!((static_foo_array_4[(i) as usize].fn1).is_none());
-        assert!((static_foo_array_4[(i) as usize].fn2).is_none());
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_foo_array_4))[(i) as usize].s2)
+                .is_null()
+        );
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_foo_array_4))[(i) as usize]
+                .fn1)
+                .is_none()
+        );
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut static_foo_array_4))[(i) as usize]
+                .fn2)
+                .is_none()
+        );
         i.prefix_inc();
     }
     (unsafe { check_local_static_5() });
diff --git a/tests/unit/out/unsafe/destructor.rs b/tests/unit/out/unsafe/destructor.rs
index 4f8e74d18..af70431d2 100644
--- a/tests/unit/out/unsafe/destructor.rs
+++ b/tests/unit/out/unsafe/destructor.rs
@@ -6,13 +6,13 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut global_0: i32 = unsafe { 0 };
+pub static mut global_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(Clone, Default)]
 pub struct S {}
 impl S {
     pub unsafe fn destructor(&mut self) {
-        global_0.postfix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)).postfix_inc();
     }
 }
 #[repr(C)]
@@ -81,9 +81,9 @@ pub struct Templated_char_ {
 }
 impl Templated_char_ {
     pub unsafe fn destructor(&mut self) {
-        global_0 = ((global_0 as usize)
-            .wrapping_add((::std::mem::size_of::<libc::c_char>() as usize)))
-            as i32;
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) =
+            (((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) as usize)
+                .wrapping_add((::std::mem::size_of::<libc::c_char>() as usize))) as i32;
     }
 }
 #[repr(C)]
@@ -93,8 +93,9 @@ pub struct Templated_int_ {
 }
 impl Templated_int_ {
     pub unsafe fn destructor(&mut self) {
-        global_0 =
-            ((global_0 as usize).wrapping_add((::std::mem::size_of::<i32>() as usize))) as i32;
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) =
+            (((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) as usize)
+                .wrapping_add((::std::mem::size_of::<i32>() as usize))) as i32;
     }
 }
 #[repr(C)]
@@ -104,11 +105,12 @@ pub struct Copied {
 }
 impl Copied {
     pub unsafe fn destructor(&mut self) {
-        global_0.postfix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)).postfix_inc();
     }
 }
-pub static mut order_1: [i32; 3] = unsafe { [0_i32; 3] };
-pub static mut order_count_2: i32 = unsafe { 0 };
+pub static mut order_1: std::cell::LazyCell<[i32; 3]> =
+    std::cell::LazyCell::new(|| unsafe { [0_i32; 3] });
+pub static mut order_count_2: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(Clone, Default)]
 pub struct Tagged {
@@ -116,7 +118,9 @@ pub struct Tagged {
 }
 impl Tagged {
     pub unsafe fn destructor(&mut self) {
-        order_1[(order_count_2.postfix_inc()) as usize] = self.tag;
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut order_1))
+            [((*std::cell::LazyCell::force_mut(&mut *&raw mut order_count_2)).postfix_inc())
+                as usize] = self.tag;
     }
 }
 #[repr(C)]
@@ -145,36 +149,36 @@ unsafe fn main_0() -> i32 {
         let mut s: S = S {};
         let _dtor_s = ScopedDestructorUnsafe::new(&raw mut s, S::destructor);
     }
-    assert!(((global_0) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (1)));
     {
         let mut s: S = S {};
         let _dtor_s = ScopedDestructorUnsafe::new(&raw mut s, S::destructor);
     }
-    assert!(((global_0) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (2)));
     {
         let mut d: Defaulted = Defaulted { s: S {} };
         let _dtor_d = ScopedDestructorUnsafe::new(&raw mut d, Defaulted::destructor);
     }
-    assert!(((global_0) == (3)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (3)));
     {
         let mut o: Outer = Outer {
             m: Middle { s: S {} },
         };
         let _dtor_o = ScopedDestructorUnsafe::new(&raw mut o, Outer::destructor);
     }
-    assert!(((global_0) == (4)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (4)));
     {
         let mut am: ArrayMember = ArrayMember {
             items: [S {}, S {}, S {}],
         };
         let _dtor_am = ScopedDestructorUnsafe::new(&raw mut am, ArrayMember::destructor);
     }
-    assert!(((global_0) == (7)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (7)));
     {
         let mut e: EmptyBody = EmptyBody { s: S {} };
         let _dtor_e = ScopedDestructorUnsafe::new(&raw mut e, EmptyBody::destructor);
     }
-    assert!(((global_0) == (8)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (8)));
     {
         let mut tc: Templated_char_ = Templated_char_ {
             v: (0 as libc::c_char),
@@ -183,7 +187,7 @@ unsafe fn main_0() -> i32 {
         let mut ti: Templated_int_ = Templated_int_ { v: 0_i32 };
         let _dtor_ti = ScopedDestructorUnsafe::new(&raw mut ti, Templated_int_::destructor);
     }
-    assert!(((global_0) == (13)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (13)));
     {
         let mut a: Copied = Copied { v: 5 };
         let _dtor_a = ScopedDestructorUnsafe::new(&raw mut a, Copied::destructor);
@@ -191,7 +195,7 @@ unsafe fn main_0() -> i32 {
         let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Copied::destructor);
         assert!(((b.v) == (5)));
     }
-    assert!(((global_0) == (15)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (15)));
     {
         let mut o: Ordered = Ordered {
             first: Tagged { tag: 1 },
@@ -202,9 +206,9 @@ unsafe fn main_0() -> i32 {
         };
         let _dtor_o = ScopedDestructorUnsafe::new(&raw mut o, Ordered::destructor);
     }
-    assert!(((order_count_2) == (3)));
-    assert!(((order_1[(0) as usize]) == (3)));
-    assert!(((order_1[(1) as usize]) == (2)));
-    assert!(((order_1[(2) as usize]) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut order_count_2)) == (3)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut order_1))[(0) as usize]) == (3)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut order_1))[(1) as usize]) == (2)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut order_1))[(2) as usize]) == (1)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/enum_comparisson_in_globals.rs b/tests/unit/out/unsafe/enum_comparisson_in_globals.rs
index aca69a0e2..50a548dc5 100644
--- a/tests/unit/out/unsafe/enum_comparisson_in_globals.rs
+++ b/tests/unit/out/unsafe/enum_comparisson_in_globals.rs
@@ -9,13 +9,14 @@ use std::rc::Rc;
 pub type E = u32;
 pub const E_A: E = 0;
 pub const E_B: E = 1;
-pub static mut global_0: i32 = unsafe { (((E_A as i32) != (E_B as i32)) as i32) };
+pub static mut global_0: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { (((E_A as i32) != (E_B as i32)) as i32) });
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((global_0) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (1)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/enum_default_in_static.rs b/tests/unit/out/unsafe/enum_default_in_static.rs
index a4818b42a..a6ac3fd39 100644
--- a/tests/unit/out/unsafe/enum_default_in_static.rs
+++ b/tests/unit/out/unsafe/enum_default_in_static.rs
@@ -16,19 +16,25 @@ pub struct Config {
     pub count: i32,
     pub mode: Mode,
 }
-pub static mut config_0: Config = unsafe {
+pub static mut config_0: std::cell::LazyCell<Config> = std::cell::LazyCell::new(|| unsafe {
     Config {
         count: 0_i32,
         mode: Mode_MODE_NONE,
     }
-};
+});
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((((config_0.count) == (0)) as i32) != 0));
-    assert!(((((config_0.mode as u32) == ((Mode_MODE_NONE as i32) as u32)) as i32) != 0));
+    assert!(
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut config_0)).count) == (0)) as i32) != 0)
+    );
+    assert!(
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut config_0)).mode as u32)
+            == ((Mode_MODE_NONE as i32) as u32)) as i32)
+            != 0)
+    );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/enum_int_interop.rs b/tests/unit/out/unsafe/enum_int_interop.rs
index 8c64334d8..609e17ac4 100644
--- a/tests/unit/out/unsafe/enum_int_interop.rs
+++ b/tests/unit/out/unsafe/enum_int_interop.rs
@@ -26,10 +26,13 @@ pub struct Entry {
     pub color: Color,
     pub opt: Option,
 }
-pub static mut global_color_0: Color = unsafe { Color_GREEN };
-pub static mut global_opt_1: Option = unsafe { Option_OPT_B };
-pub static mut global_tag_2: Tag = unsafe { Tag_TAG_TWO };
-pub static mut entries_3: [Entry; 3] = unsafe {
+pub static mut global_color_0: std::cell::LazyCell<Color> =
+    std::cell::LazyCell::new(|| unsafe { Color_GREEN });
+pub static mut global_opt_1: std::cell::LazyCell<Option> =
+    std::cell::LazyCell::new(|| unsafe { Option_OPT_B });
+pub static mut global_tag_2: std::cell::LazyCell<Tag> =
+    std::cell::LazyCell::new(|| unsafe { Tag_TAG_TWO });
+pub static mut entries_3: std::cell::LazyCell<[Entry; 3]> = std::cell::LazyCell::new(|| unsafe {
     [
         Entry {
             name: c"first".as_ptr(),
@@ -47,7 +50,7 @@ pub static mut entries_3: [Entry; 3] = unsafe {
             opt: Option_OPT_C,
         },
     ]
-};
+});
 pub unsafe fn as_int_4(mut c: Color) -> i32 {
     return (c as i32);
 }
@@ -155,14 +158,41 @@ unsafe fn main_0() -> i32 {
     };
     let mut extra: i32 = (((Color_RED as i32) + (Color_GREEN as i32)) + (Color_BLUE as i32));
     assert!(((extra) == (((0) + (1)) + (2))));
-    assert!(((global_color_0 as i32) == (Color_GREEN as i32)));
-    assert!(((global_opt_1 as i32) == (Option_OPT_B as i32)));
-    assert!(((global_tag_2 as i32) == (Tag_TAG_TWO as i32)));
-    assert!(((entries_3[(0) as usize].color as i32) == (Color_RED as i32)));
-    assert!(((entries_3[(0) as usize].opt as i32) == (Option_OPT_NONE as i32)));
-    assert!(((entries_3[(1) as usize].color as i32) == (Color_GREEN as i32)));
-    assert!(((entries_3[(1) as usize].opt as i32) == (Option_OPT_A as i32)));
-    assert!(((entries_3[(2) as usize].color as i32) == (Color_BLUE as i32)));
-    assert!(((entries_3[(2) as usize].opt as i32) == (Option_OPT_C as i32)));
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut global_color_0)) as i32)
+            == (Color_GREEN as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut global_opt_1)) as i32)
+            == (Option_OPT_B as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut global_tag_2)) as i32)
+            == (Tag_TAG_TWO as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(0) as usize].color as i32)
+            == (Color_RED as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(0) as usize].opt as i32)
+            == (Option_OPT_NONE as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(1) as usize].color as i32)
+            == (Color_GREEN as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(1) as usize].opt as i32)
+            == (Option_OPT_A as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(2) as usize].color as i32)
+            == (Color_BLUE as i32))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(2) as usize].opt as i32)
+            == (Option_OPT_C as i32))
+    );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/enum_int_interop_c.rs b/tests/unit/out/unsafe/enum_int_interop_c.rs
index aae64f612..8c03454b7 100644
--- a/tests/unit/out/unsafe/enum_int_interop_c.rs
+++ b/tests/unit/out/unsafe/enum_int_interop_c.rs
@@ -26,10 +26,13 @@ pub struct Entry {
     pub color: Color,
     pub opt: Option,
 }
-pub static mut global_color_0: Color = unsafe { Color_GREEN };
-pub static mut global_opt_1: Option = unsafe { Option_OPT_B };
-pub static mut global_tag_2: Tag_enum = unsafe { Tag_enum_TAG_TWO };
-pub static mut entries_3: [Entry; 3] = unsafe {
+pub static mut global_color_0: std::cell::LazyCell<Color> =
+    std::cell::LazyCell::new(|| unsafe { Color_GREEN });
+pub static mut global_opt_1: std::cell::LazyCell<Option> =
+    std::cell::LazyCell::new(|| unsafe { Option_OPT_B });
+pub static mut global_tag_2: std::cell::LazyCell<Tag_enum> =
+    std::cell::LazyCell::new(|| unsafe { Tag_enum_TAG_TWO });
+pub static mut entries_3: std::cell::LazyCell<[Entry; 3]> = std::cell::LazyCell::new(|| unsafe {
     [
         Entry {
             name: (c"first".as_ptr().cast_mut()).cast_const(),
@@ -47,7 +50,7 @@ pub static mut entries_3: [Entry; 3] = unsafe {
             opt: Option_OPT_C,
         },
     ]
-};
+});
 pub unsafe fn as_int_4(mut c: Color) -> i32 {
     return (c as i32);
 }
@@ -155,26 +158,50 @@ unsafe fn main_0() -> i32 {
     };
     let mut extra: i32 = (((Color_RED as i32) + (Color_GREEN as i32)) + (Color_BLUE as i32));
     assert!(((((extra) == (((0) + (1)) + (2))) as i32) != 0));
-    assert!(((((global_color_0 as u32) == ((Color_GREEN as i32) as u32)) as i32) != 0));
-    assert!(((((global_opt_1 as u32) == ((Option_OPT_B as i32) as u32)) as i32) != 0));
-    assert!(((((global_tag_2 as u32) == ((Tag_enum_TAG_TWO as i32) as u32)) as i32) != 0));
     assert!(
-        ((((entries_3[(0) as usize].color as u32) == ((Color_RED as i32) as u32)) as i32) != 0)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut global_color_0)) as u32)
+            == ((Color_GREEN as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut global_opt_1)) as u32)
+            == ((Option_OPT_B as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut global_tag_2)) as u32)
+            == ((Tag_enum_TAG_TWO as i32) as u32)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(0) as usize].color as u32)
+            == ((Color_RED as i32) as u32)) as i32)
+            != 0)
     );
     assert!(
-        ((((entries_3[(0) as usize].opt as u32) == ((Option_OPT_NONE as i32) as u32)) as i32) != 0)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(0) as usize].opt as u32)
+            == ((Option_OPT_NONE as i32) as u32)) as i32)
+            != 0)
     );
     assert!(
-        ((((entries_3[(1) as usize].color as u32) == ((Color_GREEN as i32) as u32)) as i32) != 0)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(1) as usize].color as u32)
+            == ((Color_GREEN as i32) as u32)) as i32)
+            != 0)
     );
     assert!(
-        ((((entries_3[(1) as usize].opt as u32) == ((Option_OPT_A as i32) as u32)) as i32) != 0)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(1) as usize].opt as u32)
+            == ((Option_OPT_A as i32) as u32)) as i32)
+            != 0)
     );
     assert!(
-        ((((entries_3[(2) as usize].color as u32) == ((Color_BLUE as i32) as u32)) as i32) != 0)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(2) as usize].color as u32)
+            == ((Color_BLUE as i32) as u32)) as i32)
+            != 0)
     );
     assert!(
-        ((((entries_3[(2) as usize].opt as u32) == ((Option_OPT_C as i32) as u32)) as i32) != 0)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(2) as usize].opt as u32)
+            == ((Option_OPT_C as i32) as u32)) as i32)
+            != 0)
     );
     let mut names: [*const libc::c_char; 3] = [
         (c"red".as_ptr().cast_mut()).cast_const(),
@@ -186,16 +213,20 @@ unsafe fn main_0() -> i32 {
         (((((*names[(idx) as usize].offset((0) as isize)) as i32) == ('g' as i32)) as i32) != 0)
     );
     assert!(
-        ((((entries_3[(idx) as usize].opt as u32) == ((Option_OPT_A as i32) as u32)) as i32) != 0)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(idx) as usize].opt as u32)
+            == ((Option_OPT_A as i32) as u32)) as i32)
+            != 0)
     );
     assert!(
-        (((((*names[(global_tag_2) as usize].offset((0) as isize)) as i32) == ('b' as i32))
-            as i32)
+        (((((*names[(*std::cell::LazyCell::force_mut(&mut *&raw mut global_tag_2)) as usize]
+            .offset((0) as isize)) as i32)
+            == ('b' as i32)) as i32)
             != 0)
     );
     let mut pp: *mut *const libc::c_char = (&mut names[(idx) as usize] as *mut *const libc::c_char);
     assert!((((((*(*pp).offset((0) as isize)) as i32) == ('g' as i32)) as i32) != 0));
-    let mut pe: *mut Entry = (&mut entries_3[(idx) as usize] as *mut Entry);
+    let mut pe: *mut Entry = (&mut (*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))
+        [(idx) as usize] as *mut Entry);
     assert!((((((*pe).opt as u32) == ((Option_OPT_A as i32) as u32)) as i32) != 0));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/fn_ptr_global.rs b/tests/unit/out/unsafe/fn_ptr_global.rs
index 5cca8fd51..a07053e2a 100644
--- a/tests/unit/out/unsafe/fn_ptr_global.rs
+++ b/tests/unit/out/unsafe/fn_ptr_global.rs
@@ -12,13 +12,14 @@ pub unsafe fn double_it_0(mut x: i32) -> i32 {
 pub unsafe fn triple_it_1(mut x: i32) -> i32 {
     return ((x) * (3));
 }
-pub static mut g_op_2: Option<unsafe fn(i32) -> i32> = unsafe { None };
+pub static mut g_op_2: std::cell::LazyCell<Option<unsafe fn(i32) -> i32>> =
+    std::cell::LazyCell::new(|| unsafe { None });
 pub unsafe fn set_op_3(mut fn_: Option<unsafe fn(i32) -> i32>) {
-    g_op_2 = fn_;
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut g_op_2)) = fn_;
 }
 pub unsafe fn call_op_4(mut x: i32) -> i32 {
-    if !(g_op_2).is_none() {
-        return (unsafe { (g_op_2).unwrap()(x) });
+    if !(*std::cell::LazyCell::force_mut(&mut *&raw mut g_op_2)).is_none() {
+        return (unsafe { (*std::cell::LazyCell::force_mut(&mut *&raw mut g_op_2)).unwrap()(x) });
     }
     return x;
 }
@@ -30,14 +31,14 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     assert!(((unsafe { call_op_4(5,) }) == (5)));
     (unsafe { set_op_3(Some(double_it_0)) });
-    assert!(!((g_op_2).is_none()));
-    assert!(((g_op_2) == (Some(double_it_0))));
+    assert!(!((*std::cell::LazyCell::force_mut(&mut *&raw mut g_op_2)).is_none()));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut g_op_2)) == (Some(double_it_0))));
     assert!(((unsafe { call_op_4(5,) }) == (10)));
     (unsafe { set_op_3(Some(triple_it_1)) });
-    assert!(((g_op_2) == (Some(triple_it_1))));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut g_op_2)) == (Some(triple_it_1))));
     assert!(((unsafe { call_op_4(5,) }) == (15)));
     (unsafe { set_op_3(None) });
-    assert!((g_op_2).is_none());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut g_op_2)).is_none());
     assert!(((unsafe { call_op_4(5,) }) == (5)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/fn_ptr_vtable.rs b/tests/unit/out/unsafe/fn_ptr_vtable.rs
index 5eff7364d..4d1863ec1 100644
--- a/tests/unit/out/unsafe/fn_ptr_vtable.rs
+++ b/tests/unit/out/unsafe/fn_ptr_vtable.rs
@@ -22,10 +22,11 @@ impl Default for Vtable {
         }
     }
 }
-pub static mut storage_0: i32 = unsafe { 0_i32 };
+pub static mut storage_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0_i32 });
 pub unsafe fn int_create_1(mut val: i32) -> *mut ::libc::c_void {
-    storage_0 = val;
-    return ((&raw mut storage_0 as *mut i32) as *mut i32 as *mut ::libc::c_void);
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut storage_0)) = val;
+    return ((&raw mut (*std::cell::LazyCell::force_mut(&mut *&raw mut storage_0)) as *mut i32)
+        as *mut i32 as *mut ::libc::c_void);
 }
 pub unsafe fn int_get_2(mut p: *mut ::libc::c_void) -> i32 {
     return (*(p as *mut i32));
@@ -50,7 +51,7 @@ unsafe fn main_0() -> i32 {
     let mut obj: *mut ::libc::c_void = (unsafe { (vt.create).unwrap()(42) });
     assert!(((unsafe { (vt.get).unwrap()(obj,) }) == (42)));
     (unsafe { (vt.destroy).unwrap()(obj) });
-    assert!(((storage_0) == (0)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut storage_0)) == (0)));
     (vt.get) = None;
     assert!((vt.get).is_none());
     return 0;
diff --git a/tests/unit/out/unsafe/global-initialization-using-global.rs b/tests/unit/out/unsafe/global-initialization-using-global.rs
index ec9868ee0..93f718e9e 100644
--- a/tests/unit/out/unsafe/global-initialization-using-global.rs
+++ b/tests/unit/out/unsafe/global-initialization-using-global.rs
@@ -6,15 +6,20 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut first_0: i32 = unsafe { 0_i32 };
-pub static mut second_1: i32 = unsafe { ((first_0) + (1)) };
+pub static mut first_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0_i32 });
+pub static mut second_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe {
+    ((*std::cell::LazyCell::force_mut(&mut *&raw mut first_0)) + (1))
+});
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((first_0) == (0)));
-    assert!(((second_1) == ((first_0) + (1))));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut first_0)) == (0)));
+    assert!(
+        ((*std::cell::LazyCell::force_mut(&mut *&raw mut second_1))
+            == ((*std::cell::LazyCell::force_mut(&mut *&raw mut first_0)) + (1)))
+    );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/global_non_const_init.rs b/tests/unit/out/unsafe/global_non_const_init.rs
index 44b18d185..98bc9f062 100644
--- a/tests/unit/out/unsafe/global_non_const_init.rs
+++ b/tests/unit/out/unsafe/global_non_const_init.rs
@@ -7,22 +7,26 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn next_0() -> i32 {
-    static mut counter_1: i32 = unsafe { 0 };;
-    return counter_1.prefix_inc();
+    static mut counter_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut counter_1)).prefix_inc();
 }
 pub unsafe fn marker_2(mut tag: u8) -> u8 {
     return ((((tag as i32) << (3)) | (2)) as u8);
 }
-pub static mut signature_3: [u8; 3] = unsafe {
+pub static mut signature_3: std::cell::LazyCell<[u8; 3]> = std::cell::LazyCell::new(|| unsafe {
     [
         (unsafe { marker_2(1_u8) }),
         4_u8,
         (('B' as libc::c_char) as u8),
     ]
-};
-pub static mut single_4: u8 = unsafe { (unsafe { marker_2(2_u8) }) };
-pub static mut from_call_5: i32 = unsafe { (unsafe { next_0() }) };
-pub static mut depends_on_call_6: i32 = unsafe { ((from_call_5) + (1)) };
+});
+pub static mut single_4: std::cell::LazyCell<u8> =
+    std::cell::LazyCell::new(|| unsafe { (unsafe { marker_2(2_u8) }) });
+pub static mut from_call_5: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { (unsafe { next_0() }) });
+pub static mut depends_on_call_6: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe {
+    ((*std::cell::LazyCell::force_mut(&mut *&raw mut from_call_5)) + (1))
+});
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct Ctor {
@@ -45,23 +49,32 @@ impl Default for Ctor {
         unsafe { Ctor::Ctor1() }
     }
 }
-pub static mut default_ctor_7: Ctor = unsafe { Ctor::Ctor1() };
-pub static mut arg_ctor_8: Ctor = unsafe { Ctor::Ctor2({ 7 }) };
-pub static mut str_9: Vec<libc::c_char> = unsafe {
-    {
-        let s = c"abc".as_ptr();
-        std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
-    }
-};
-pub static mut inline_member_11: Ctor = unsafe { Ctor::Ctor2({ 5 }) };
+pub static mut default_ctor_7: std::cell::LazyCell<Ctor> =
+    std::cell::LazyCell::new(|| unsafe { Ctor::Ctor1() });
+pub static mut arg_ctor_8: std::cell::LazyCell<Ctor> =
+    std::cell::LazyCell::new(|| unsafe { Ctor::Ctor2({ 7 }) });
+pub static mut str_9: std::cell::LazyCell<Vec<libc::c_char>> =
+    std::cell::LazyCell::new(|| unsafe {
+        {
+            let s = c"abc".as_ptr();
+            std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
+                .to_vec()
+        }
+    });
+pub static mut inline_member_11: std::cell::LazyCell<Ctor> =
+    std::cell::LazyCell::new(|| unsafe { Ctor::Ctor2({ 5 }) });
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Holder {}
-pub static mut member_10: i32 = unsafe { (unsafe { next_0() }) };
+pub static mut member_10: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { (unsafe { next_0() }) });
 pub unsafe fn local_static_12() -> i32 {
-    static mut once_13: i32 = unsafe { (unsafe { next_0() }) };;
-    static mut local_ctor_14: Ctor = unsafe { Ctor::Ctor2({ 3 }) };;
-    return ((once_13) + (local_ctor_14.v));
+    static mut once_13: std::cell::LazyCell<i32> =
+        std::cell::LazyCell::new(|| unsafe { (unsafe { next_0() }) });;
+    static mut local_ctor_14: std::cell::LazyCell<Ctor> =
+        std::cell::LazyCell::new(|| unsafe { Ctor::Ctor2({ 3 }) });;
+    return ((*std::cell::LazyCell::force_mut(&mut *&raw mut once_13))
+        + ((*std::cell::LazyCell::force_mut(&mut *&raw mut local_ctor_14)).v));
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -74,8 +87,9 @@ impl Singleton {
         this
     }
     pub unsafe fn instance() -> *mut Singleton {
-        static mut s_15: Singleton = unsafe { Singleton::Singleton() };;
-        return &mut s_15 as *mut Singleton;
+        static mut s_15: std::cell::LazyCell<Singleton> =
+            std::cell::LazyCell::new(|| unsafe { Singleton::Singleton() });;
+        return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut s_15)) as *mut Singleton;
     }
 }
 impl Default for Singleton {
@@ -89,22 +103,28 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((signature_3[(0) as usize] as i32) == (10)));
-    assert!(((signature_3[(1) as usize] as i32) == (4)));
-    assert!(((single_4 as i32) == (18)));
-    assert!(((from_call_5) == (1)));
-    assert!(((depends_on_call_6) == (2)));
-    assert!(((default_ctor_7.v) == (2)));
-    assert!(((arg_ctor_8.v) == (7)));
     assert!(
-        str_9 == {
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut signature_3))[(0) as usize] as i32)
+            == (10))
+    );
+    assert!(
+        (((*std::cell::LazyCell::force_mut(&mut *&raw mut signature_3))[(1) as usize] as i32)
+            == (4))
+    );
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut single_4)) as i32) == (18)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut from_call_5)) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut depends_on_call_6)) == (2)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut default_ctor_7)).v) == (2)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut arg_ctor_8)).v) == (7)));
+    assert!(
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut str_9)) == {
             let s = c"abc".as_ptr();
             std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
                 .to_vec()
         }
     );
-    assert!(((member_10) == (3)));
-    assert!(((inline_member_11.v) == (5)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut member_10)) == (3)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut inline_member_11)).v) == (5)));
     assert!(((unsafe { local_static_12() }) == (7)));
     assert!(((unsafe { local_static_12() }) == (7)));
     (*(unsafe { Singleton::instance() })).hits.postfix_inc();
diff --git a/tests/unit/out/unsafe/global_pointers.rs b/tests/unit/out/unsafe/global_pointers.rs
index a9426e521..e25bb3ead 100644
--- a/tests/unit/out/unsafe/global_pointers.rs
+++ b/tests/unit/out/unsafe/global_pointers.rs
@@ -12,13 +12,13 @@ pub struct Entry {
     pub name: *const libc::c_char,
     pub p: *mut i32,
 }
-pub static mut single_entry_0: Entry = unsafe {
+pub static mut single_entry_0: std::cell::LazyCell<Entry> = std::cell::LazyCell::new(|| unsafe {
     Entry {
         name: c"alone".as_ptr(),
         p: std::ptr::null_mut(),
     }
-};
-pub static mut entries_1: [Entry; 2] = unsafe {
+});
+pub static mut entries_1: std::cell::LazyCell<[Entry; 2]> = std::cell::LazyCell::new(|| unsafe {
     [
         Entry {
             name: c"first".as_ptr(),
@@ -29,25 +29,31 @@ pub static mut entries_1: [Entry; 2] = unsafe {
             p: std::ptr::null_mut(),
         },
     ]
-};
-pub static mut arr_of_pointers_2: [*mut libc::c_char; 3] = unsafe {
-    [
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-        std::ptr::null_mut(),
-    ]
-};
+});
+pub static mut arr_of_pointers_2: std::cell::LazyCell<[*mut libc::c_char; 3]> =
+    std::cell::LazyCell::new(|| unsafe {
+        [
+            std::ptr::null_mut(),
+            std::ptr::null_mut(),
+            std::ptr::null_mut(),
+        ]
+    });
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!((single_entry_0.p).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut single_entry_0)).p).is_null());
     let mut i: i32 = 0;
     'loop_: while ((i) < (2)) {
-        assert!((entries_1[(i) as usize].p).is_null());
-        assert!((arr_of_pointers_2[(i) as usize]).is_null());
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_1))[(i) as usize].p).is_null()
+        );
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut arr_of_pointers_2))[(i) as usize])
+                .is_null()
+        );
         i.prefix_inc();
     }
     return 0;
diff --git a/tests/unit/out/unsafe/global_without_initializer.rs b/tests/unit/out/unsafe/global_without_initializer.rs
index f47f77d9e..8b8f1c58f 100644
--- a/tests/unit/out/unsafe/global_without_initializer.rs
+++ b/tests/unit/out/unsafe/global_without_initializer.rs
@@ -11,17 +11,19 @@ use std::rc::Rc;
 pub struct S {
     pub a: i32,
 }
-pub static mut s_0: *mut S = unsafe { std::ptr::null_mut() };
-pub static mut file_1: *mut ::libc::FILE = unsafe { std::ptr::null_mut() };
-pub static mut size_2: usize = unsafe { 0_usize };
+pub static mut s_0: std::cell::LazyCell<*mut S> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null_mut() });
+pub static mut file_1: std::cell::LazyCell<*mut ::libc::FILE> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null_mut() });
+pub static mut size_2: std::cell::LazyCell<usize> = std::cell::LazyCell::new(|| unsafe { 0_usize });
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!((s_0).is_null());
-    assert!((file_1).is_null());
-    assert!(((size_2) == (0_usize)));
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut s_0)).is_null());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut file_1)).is_null());
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut size_2)) == (0_usize)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/null_in_statics.rs b/tests/unit/out/unsafe/null_in_statics.rs
index 2c26d414c..98f4b718e 100644
--- a/tests/unit/out/unsafe/null_in_statics.rs
+++ b/tests/unit/out/unsafe/null_in_statics.rs
@@ -6,35 +6,49 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut p_mut_0: *mut i32 = unsafe { std::ptr::null_mut() };
-pub static mut p_const_1: *const i32 = unsafe { std::ptr::null() };
-pub static mut cp_2: *const libc::c_char = unsafe { std::ptr::null() };
-pub static mut arr_of_ptr_3: [*mut i32; 4] = unsafe { [std::ptr::null_mut(); 4] };
-pub static mut pp_4: *mut *mut i32 = unsafe { std::ptr::null_mut() };
-pub static mut const_arr_of_ptr_5: [*const i32; 3] = unsafe { [std::ptr::null(); 3] };
-pub static mut cp_explicit_null_6: *const libc::c_char = unsafe { std::ptr::null() };
-pub static mut p_zero_7: *mut i32 = unsafe { std::ptr::null_mut() };
+pub static mut p_mut_0: std::cell::LazyCell<*mut i32> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null_mut() });
+pub static mut p_const_1: std::cell::LazyCell<*const i32> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null() });
+pub static mut cp_2: std::cell::LazyCell<*const libc::c_char> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null() });
+pub static mut arr_of_ptr_3: std::cell::LazyCell<[*mut i32; 4]> =
+    std::cell::LazyCell::new(|| unsafe { [std::ptr::null_mut(); 4] });
+pub static mut pp_4: std::cell::LazyCell<*mut *mut i32> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null_mut() });
+pub static mut const_arr_of_ptr_5: std::cell::LazyCell<[*const i32; 3]> =
+    std::cell::LazyCell::new(|| unsafe { [std::ptr::null(); 3] });
+pub static mut cp_explicit_null_6: std::cell::LazyCell<*const libc::c_char> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null() });
+pub static mut p_zero_7: std::cell::LazyCell<*mut i32> =
+    std::cell::LazyCell::new(|| unsafe { std::ptr::null_mut() });
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!((p_mut_0).is_null());
-    assert!((p_const_1).is_null());
-    assert!((cp_2).is_null());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut p_mut_0)).is_null());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut p_const_1)).is_null());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut cp_2)).is_null());
     let mut i: i32 = 0;
     'loop_: while ((i) < (4)) {
-        assert!((arr_of_ptr_3[(i) as usize]).is_null());
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut arr_of_ptr_3))[(i) as usize])
+                .is_null()
+        );
         i.prefix_inc();
     }
-    assert!((pp_4).is_null());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut pp_4)).is_null());
     let mut i: i32 = 0;
     'loop_: while ((i) < (3)) {
-        assert!((const_arr_of_ptr_5[(i) as usize]).is_null());
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut const_arr_of_ptr_5))[(i) as usize])
+                .is_null()
+        );
         i.prefix_inc();
     }
-    assert!((cp_explicit_null_6).is_null());
-    assert!((p_zero_7).is_null());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut cp_explicit_null_6)).is_null());
+    assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut p_zero_7)).is_null());
     return 0;
 }
diff --git a/tests/unit/out/unsafe/operator_member_pointer_member.rs b/tests/unit/out/unsafe/operator_member_pointer_member.rs
index bcc55d81b..e8b9ea3ca 100644
--- a/tests/unit/out/unsafe/operator_member_pointer_member.rs
+++ b/tests/unit/out/unsafe/operator_member_pointer_member.rs
@@ -16,10 +16,12 @@ pub struct Inner {
 pub struct Table {}
 impl Table {
     pub unsafe fn operator_index(mut i: i32) -> *mut i32 {
-        return &mut table_0[(i) as usize] as *mut i32;
+        return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut table_0))[(i) as usize]
+            as *mut i32;
     }
 }
-pub static mut table_0: [i32; 3] = unsafe { [7, 8, 9] };
+pub static mut table_0: std::cell::LazyCell<[i32; 3]> =
+    std::cell::LazyCell::new(|| unsafe { [7, 8, 9] });
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct S {
@@ -78,6 +80,6 @@ unsafe fn main_0() -> i32 {
     let mut t: Table = <Table>::default();
     assert!(((*(unsafe { Table::operator_index(1,) })) == (8)));
     (*(unsafe { Table::operator_index(1) })) = 80;
-    assert!(((table_0[(1) as usize]) == (80)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut table_0))[(1) as usize]) == (80)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/rule_of_five.rs b/tests/unit/out/unsafe/rule_of_five.rs
index eaf5d228a..08662359f 100644
--- a/tests/unit/out/unsafe/rule_of_five.rs
+++ b/tests/unit/out/unsafe/rule_of_five.rs
@@ -6,9 +6,9 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut alive_0: i32 = unsafe { 0 };
-pub static mut copies_1: i32 = unsafe { 0 };
-pub static mut moves_2: i32 = unsafe { 0 };
+pub static mut alive_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+pub static mut copies_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+pub static mut moves_2: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive()]
 pub struct Buffer {
@@ -26,11 +26,11 @@ impl Buffer {
             this.data[(i) as usize] = if ((i) < (size)) { i } else { -1_i32 };
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
         this
     }
     pub unsafe fn destructor(&mut self) {
-        alive_0.prefix_dec();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_dec();
     }
     pub unsafe fn Buffer_pconstBuffer(o: *const Buffer) -> Self {
         let mut this = Self {
@@ -42,8 +42,8 @@ impl Buffer {
             this.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         this
     }
     pub unsafe fn Buffer_pmutBuffer(o: *mut Buffer) -> Self {
@@ -58,8 +58,8 @@ impl Buffer {
             i.prefix_inc();
         }
         (*o).size = 0;
-        alive_0.prefix_inc();
-        moves_2.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)).prefix_inc();
         this
     }
     pub unsafe fn operator_assign_pconstBuffer(&mut self, o: *const Buffer) -> *mut Buffer {
@@ -72,7 +72,7 @@ impl Buffer {
             self.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         return &mut (*(self as *mut Buffer)) as *mut Buffer;
     }
     pub unsafe fn operator_assign_pmutBuffer(&mut self, o: *mut Buffer) -> *mut Buffer {
@@ -87,7 +87,7 @@ impl Buffer {
             i.prefix_inc();
         }
         (*o).size = 0;
-        moves_2.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)).prefix_inc();
         return &mut (*(self as *mut Buffer)) as *mut Buffer;
     }
 }
@@ -120,27 +120,44 @@ unsafe fn main_0() -> i32 {
         let _dtor_a = ScopedDestructorUnsafe::new(&raw mut a, Buffer::destructor);
         let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a as *const Buffer });
         let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Buffer::destructor);
-        assert!((((alive_0) == (2)) && ((copies_1) == (1))) && ((moves_2) == (0)));
+        assert!(
+            (((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (2))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (1)))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (0))
+        );
         b.data[(0) as usize] = 100;
         assert!(((a.data[(0) as usize]) == (0)));
         let mut c: Buffer = Buffer::Buffer_pmutBuffer({ &mut a });
         let _dtor_c = ScopedDestructorUnsafe::new(&raw mut c, Buffer::destructor);
-        assert!(((alive_0) == (3)) && ((moves_2) == (1)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (3))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (1))
+        );
         assert!(((a.size) == (0)) && ((a.data[(0) as usize]) == (-1_i32)));
         assert!(((c.size) == (4)) && ((c.data[(3) as usize]) == (3)));
         let mut d: Buffer = (unsafe { make_3(2) });
         let _dtor_d = ScopedDestructorUnsafe::new(&raw mut d, Buffer::destructor);
-        assert!(((d.size) == (2)) && ((moves_2) == (2)));
+        assert!(
+            ((d.size) == (2)) && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (2))
+        );
         (unsafe { Buffer::operator_assign_pconstBuffer(&mut d, &b as *const Buffer) });
-        assert!((((d.size) == (4)) && ((d.data[(0) as usize]) == (100))) && ((copies_1) == (2)));
+        assert!(
+            (((d.size) == (4)) && ((d.data[(0) as usize]) == (100)))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (2))
+        );
         (unsafe { Buffer::operator_assign_pmutBuffer(&mut d, &mut c) });
-        assert!((((d.data[(0) as usize]) == (0)) && ((c.size) == (0))) && ((moves_2) == (3)));
+        assert!(
+            (((d.data[(0) as usize]) == (0)) && ((c.size) == (0)))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (3))
+        );
         (unsafe {
             let _o: *mut Buffer = &mut d;
             Buffer::operator_assign_pmutBuffer(&mut d, _o)
         });
-        assert!(((d.size) == (4)) && ((moves_2) == (3)));
+        assert!(
+            ((d.size) == (4)) && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (3))
+        );
     }
-    assert!(((alive_0) == (0)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (0)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/rule_of_three.rs b/tests/unit/out/unsafe/rule_of_three.rs
index fe1b8cb58..d3c7a2821 100644
--- a/tests/unit/out/unsafe/rule_of_three.rs
+++ b/tests/unit/out/unsafe/rule_of_three.rs
@@ -6,8 +6,8 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut alive_0: i32 = unsafe { 0 };
-pub static mut copies_1: i32 = unsafe { 0 };
+pub static mut alive_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+pub static mut copies_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive()]
 pub struct Buffer {
@@ -25,11 +25,11 @@ impl Buffer {
             this.data[(i) as usize] = if ((i) < (size)) { i } else { -1_i32 };
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
         this
     }
     pub unsafe fn destructor(&mut self) {
-        alive_0.prefix_dec();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_dec();
     }
     pub unsafe fn Buffer_pconstBuffer(o: *const Buffer) -> Self {
         let mut this = Self {
@@ -41,8 +41,8 @@ impl Buffer {
             this.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         this
     }
     pub unsafe fn operator_assign(&mut self, o: *const Buffer) -> *mut Buffer {
@@ -55,7 +55,7 @@ impl Buffer {
             self.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         return &mut (*(self as *mut Buffer)) as *mut Buffer;
     }
 }
@@ -92,29 +92,38 @@ unsafe fn main_0() -> i32 {
         let _dtor_a = ScopedDestructorUnsafe::new(&raw mut a, Buffer::destructor);
         let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a as *const Buffer });
         let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Buffer::destructor);
-        assert!(((alive_0) == (2)) && ((copies_1) == (1)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (2))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (1))
+        );
         b.data[(0) as usize] = 100;
         assert!(((a.data[(0) as usize]) == (0)));
         let mut c: Buffer = Buffer::Buffer({ 2 });
         let _dtor_c = ScopedDestructorUnsafe::new(&raw mut c, Buffer::destructor);
         (unsafe { Buffer::operator_assign(&mut c, &a as *const Buffer) });
         assert!(((c.size) == (4)) && ((c.data[(3) as usize]) == (3)));
-        assert!(((alive_0) == (3)) && ((copies_1) == (2)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (3))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (2))
+        );
         (unsafe {
             let _o: *const Buffer = &c as *const Buffer;
             Buffer::operator_assign(&mut c, _o)
         });
-        assert!(((copies_1) == (2)));
+        assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (2)));
         assert!(((unsafe { sum_2(&a as *const Buffer,) }) == (6)));
         assert!(((unsafe { sum_2(&b as *const Buffer,) }) == (106)));
         let mut d: Buffer = Buffer::Buffer_pconstBuffer({ &mut a });
         let _dtor_d = ScopedDestructorUnsafe::new(&raw mut d, Buffer::destructor);
-        assert!(((alive_0) == (4)) && ((copies_1) == (3)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (4))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (3))
+        );
         assert!(((a.size) == (4)) && ((a.data[(3) as usize]) == (3)));
         (unsafe { Buffer::operator_assign(&mut d, &mut b) });
-        assert!(((copies_1) == (4)));
+        assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (4)));
         assert!(((b.data[(0) as usize]) == (100)) && ((d.data[(0) as usize]) == (100)));
     }
-    assert!(((alive_0) == (0)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (0)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/rvalue_ref_global.rs b/tests/unit/out/unsafe/rvalue_ref_global.rs
index 6925b5e79..d34ac8e9f 100644
--- a/tests/unit/out/unsafe/rvalue_ref_global.rs
+++ b/tests/unit/out/unsafe/rvalue_ref_global.rs
@@ -7,13 +7,14 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 static mut __tmp_0: i32 = 5;
-pub static mut g_0: *mut i32 = unsafe { &mut __tmp_0 };
+pub static mut g_0: std::cell::LazyCell<*mut i32> =
+    std::cell::LazyCell::new(|| unsafe { &mut __tmp_0 });
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((*g_0) == (5)));
+    assert!(((*(*std::cell::LazyCell::force_mut(&mut *&raw mut g_0))) == (5)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/static_function_vars_same_name.rs b/tests/unit/out/unsafe/static_function_vars_same_name.rs
index e54fa241c..8ea972464 100644
--- a/tests/unit/out/unsafe/static_function_vars_same_name.rs
+++ b/tests/unit/out/unsafe/static_function_vars_same_name.rs
@@ -7,12 +7,12 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn a_0() -> i32 {
-    static mut i_1: i32 = unsafe { 1 };;
-    return i_1;
+    static mut i_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 1 });;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut i_1));
 }
 pub unsafe fn b_2() -> i32 {
-    static mut i_3: i32 = unsafe { 2 };;
-    return i_3;
+    static mut i_3: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 2 });;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut i_3));
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/static_local.rs b/tests/unit/out/unsafe/static_local.rs
index 96d2b8192..14f93bd27 100644
--- a/tests/unit/out/unsafe/static_local.rs
+++ b/tests/unit/out/unsafe/static_local.rs
@@ -7,13 +7,17 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn foo_0() -> i32 {
-    static mut static_i_1: i32 = unsafe { 0_i32 };;
-    static mut static_f_2: f32 = unsafe { 0.0_f32 };;
-    static mut static_b_3: bool = unsafe { false };;
-    static mut kX1_4: i32 = unsafe { 1 };;
-    static mut kX2_5: i32 = unsafe { 2 };;
-    kX1_4 += 1;
-    return (((kX1_4) + (kX2_5)) + (static_i_1));
+    static mut static_i_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0_i32 });;
+    static mut static_f_2: std::cell::LazyCell<f32> =
+        std::cell::LazyCell::new(|| unsafe { 0.0_f32 });;
+    static mut static_b_3: std::cell::LazyCell<bool> =
+        std::cell::LazyCell::new(|| unsafe { false });;
+    static mut kX1_4: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 1 });;
+    static mut kX2_5: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 2 });;
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut kX1_4)) += 1;
+    return (((*std::cell::LazyCell::force_mut(&mut *&raw mut kX1_4))
+        + (*std::cell::LazyCell::force_mut(&mut *&raw mut kX2_5)))
+        + (*std::cell::LazyCell::force_mut(&mut *&raw mut static_i_1)));
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/static_shadow.rs b/tests/unit/out/unsafe/static_shadow.rs
index 373092916..7ececeb03 100644
--- a/tests/unit/out/unsafe/static_shadow.rs
+++ b/tests/unit/out/unsafe/static_shadow.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut value_0: i32 = unsafe { 5 };
+pub static mut value_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 5 });
 pub unsafe fn param_shadow_1(mut value: i32) -> i32 {
     return ((value) + (1));
 }
@@ -15,7 +15,7 @@ pub unsafe fn local_shadow_2() -> i32 {
     return value;
 }
 pub unsafe fn read_global_3() -> i32 {
-    return value_0;
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut value_0));
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/static_var_in_class.rs b/tests/unit/out/unsafe/static_var_in_class.rs
index fa8bfa7f0..3d500e77e 100644
--- a/tests/unit/out/unsafe/static_var_in_class.rs
+++ b/tests/unit/out/unsafe/static_var_in_class.rs
@@ -6,16 +6,16 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-static mut inner_const_0: i32 = unsafe { 1 };
+static mut inner_const_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 1 });
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct C {}
 impl C {
     pub unsafe fn get(&mut self) -> i32 {
-        return inner_const_0;
+        return (*std::cell::LazyCell::force_mut(&mut *&raw mut inner_const_0));
     }
 }
-pub static mut inner_const_1: i32 = unsafe { 2 };
+pub static mut inner_const_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 2 });
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct S {}
@@ -27,6 +27,6 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut c: C = <C>::default();
     assert!(((unsafe { C::get(&mut c,) }) == (1)));
-    assert!(((inner_const_1) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut inner_const_1)) == (2)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/string_escape.rs b/tests/unit/out/unsafe/string_escape.rs
index af93a63e7..3acb7398a 100644
--- a/tests/unit/out/unsafe/string_escape.rs
+++ b/tests/unit/out/unsafe/string_escape.rs
@@ -14,57 +14,62 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut special: *const libc::c_char =
         c"\x07\x08\t\n\x0b\x0c\r !\"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\xff".as_ptr();
-    static mut expected_0: [libc::c_char; 41] = unsafe {
-        [
-            (7 as libc::c_char),
-            (8 as libc::c_char),
-            (9 as libc::c_char),
-            (10 as libc::c_char),
-            (11 as libc::c_char),
-            (12 as libc::c_char),
-            (13 as libc::c_char),
-            (32 as libc::c_char),
-            (33 as libc::c_char),
-            (34 as libc::c_char),
-            (35 as libc::c_char),
-            (36 as libc::c_char),
-            (37 as libc::c_char),
-            (38 as libc::c_char),
-            (39 as libc::c_char),
-            (40 as libc::c_char),
-            (41 as libc::c_char),
-            (42 as libc::c_char),
-            (43 as libc::c_char),
-            (44 as libc::c_char),
-            (45 as libc::c_char),
-            (46 as libc::c_char),
-            (47 as libc::c_char),
-            (58 as libc::c_char),
-            (59 as libc::c_char),
-            (60 as libc::c_char),
-            (61 as libc::c_char),
-            (62 as libc::c_char),
-            (63 as libc::c_char),
-            (64 as libc::c_char),
-            (91 as libc::c_char),
-            (92 as libc::c_char),
-            (93 as libc::c_char),
-            (94 as libc::c_char),
-            (95 as libc::c_char),
-            (96 as libc::c_char),
-            (123 as libc::c_char),
-            (124 as libc::c_char),
-            (125 as libc::c_char),
-            (126 as libc::c_char),
-            (b'\xff' as libc::c_char),
-        ]
-    };;
+    static mut expected_0: std::cell::LazyCell<[libc::c_char; 41]> =
+        std::cell::LazyCell::new(|| unsafe {
+            [
+                (7 as libc::c_char),
+                (8 as libc::c_char),
+                (9 as libc::c_char),
+                (10 as libc::c_char),
+                (11 as libc::c_char),
+                (12 as libc::c_char),
+                (13 as libc::c_char),
+                (32 as libc::c_char),
+                (33 as libc::c_char),
+                (34 as libc::c_char),
+                (35 as libc::c_char),
+                (36 as libc::c_char),
+                (37 as libc::c_char),
+                (38 as libc::c_char),
+                (39 as libc::c_char),
+                (40 as libc::c_char),
+                (41 as libc::c_char),
+                (42 as libc::c_char),
+                (43 as libc::c_char),
+                (44 as libc::c_char),
+                (45 as libc::c_char),
+                (46 as libc::c_char),
+                (47 as libc::c_char),
+                (58 as libc::c_char),
+                (59 as libc::c_char),
+                (60 as libc::c_char),
+                (61 as libc::c_char),
+                (62 as libc::c_char),
+                (63 as libc::c_char),
+                (64 as libc::c_char),
+                (91 as libc::c_char),
+                (92 as libc::c_char),
+                (93 as libc::c_char),
+                (94 as libc::c_char),
+                (95 as libc::c_char),
+                (96 as libc::c_char),
+                (123 as libc::c_char),
+                (124 as libc::c_char),
+                (125 as libc::c_char),
+                (126 as libc::c_char),
+                (b'\xff' as libc::c_char),
+            ]
+        });;
     let mut i: i32 = 0;
     'loop_: while ((i)
         < (((::std::mem::size_of::<[libc::c_char; 41]>() as usize)
             .wrapping_div((::std::mem::size_of::<libc::c_char>() as usize))) as i32))
     {
-        assert!((((*special.offset((i) as isize)) as i32) == (expected_0[(i) as usize] as i32)));
+        assert!(
+            (((*special.offset((i) as isize)) as i32)
+                == ((*std::cell::LazyCell::force_mut(&mut *&raw mut expected_0))[(i) as usize]
+                    as i32))
+        );
         i.postfix_inc();
     }
     return 0;
diff --git a/tests/unit/out/unsafe/string_literal_interior_null.rs b/tests/unit/out/unsafe/string_literal_interior_null.rs
index 27d5c0414..5e00475e8 100644
--- a/tests/unit/out/unsafe/string_literal_interior_null.rs
+++ b/tests/unit/out/unsafe/string_literal_interior_null.rs
@@ -15,14 +15,15 @@ pub unsafe fn sum_bytes_0(mut buf: *const libc::c_char, mut len: u32) -> i32 {
     }
     return sum;
 }
-pub static mut g_packet_1: *const libc::c_char = unsafe {
-    (&[
-        (1 as libc::c_char),
-        (0 as libc::c_char),
-        (0 as libc::c_char),
-    ])
-        .as_ptr()
-};
+pub static mut g_packet_1: std::cell::LazyCell<*const libc::c_char> =
+    std::cell::LazyCell::new(|| unsafe {
+        (&[
+            (1 as libc::c_char),
+            (0 as libc::c_char),
+            (0 as libc::c_char),
+        ])
+            .as_ptr()
+    });
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -40,7 +41,12 @@ unsafe fn main_0() -> i32 {
             2_u32,
         )
     });
-    let mut b: i32 = (unsafe { sum_bytes_0(g_packet_1, 2_u32) });
+    let mut b: i32 = (unsafe {
+        sum_bytes_0(
+            (*std::cell::LazyCell::force_mut(&mut *&raw mut g_packet_1)),
+            2_u32,
+        )
+    });
     assert!(((a) == (b)));
     assert!(((a) == (1)));
     let mut c: i32 = (((*c"\r\n.\r\n".as_ptr().offset((0) as isize)) as i32)
diff --git a/tests/unit/out/unsafe/string_literal_ptr_init.rs b/tests/unit/out/unsafe/string_literal_ptr_init.rs
index c6395ccfb..2f6812f7a 100644
--- a/tests/unit/out/unsafe/string_literal_ptr_init.rs
+++ b/tests/unit/out/unsafe/string_literal_ptr_init.rs
@@ -25,7 +25,7 @@ impl Default for label {
 pub unsafe fn probe_two_0() -> i32 {
     return 1;
 }
-pub static mut table_1: [label; 2] = unsafe {
+pub static mut table_1: std::cell::LazyCell<[label; 2]> = std::cell::LazyCell::new(|| unsafe {
     [
         label {
             name: ((c"first").as_ptr().cast_mut()).cast_const(),
@@ -38,7 +38,7 @@ pub static mut table_1: [label; 2] = unsafe {
             mask: ((1) << (5)),
         },
     ]
-};
+});
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
@@ -46,21 +46,48 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     assert!(
-        (((((*table_1[(0) as usize].name.offset((0) as isize)) as i32) == ('f' as i32)) as i32)
+        (((((*(*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize]
+            .name
+            .offset((0) as isize)) as i32)
+            == ('f' as i32)) as i32)
             != 0)
     );
     assert!(
-        (((((*table_1[(0) as usize].name.offset((4) as isize)) as i32) == ('t' as i32)) as i32)
+        (((((*(*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize]
+            .name
+            .offset((4) as isize)) as i32)
+            == ('t' as i32)) as i32)
             != 0)
     );
-    assert!(((((table_1[(0) as usize].probe).is_none()) as i32) != 0));
-    assert!(((((table_1[(0) as usize].mask) == (16)) as i32) != 0));
     assert!(
-        (((((*table_1[(1) as usize].name.offset((0) as isize)) as i32) == ('s' as i32)) as i32)
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize].probe)
+            .is_none()) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize].mask) == (16))
+            as i32)
+            != 0)
+    );
+    assert!(
+        (((((*(*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(1) as usize]
+            .name
+            .offset((0) as isize)) as i32)
+            == ('s' as i32)) as i32)
+            != 0)
+    );
+    assert!(
+        ((((unsafe {
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(1) as usize].probe).unwrap()(
+            )
+        }) == (1)) as i32)
+            != 0)
+    );
+    assert!(
+        (((((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(1) as usize].mask) == (32))
+            as i32)
             != 0)
     );
-    assert!(((((unsafe { (table_1[(1) as usize].probe).unwrap()() }) == (1)) as i32) != 0));
-    assert!(((((table_1[(1) as usize].mask) == (32)) as i32) != 0));
     let mut tail: *const libc::c_char = (&mut (*c"ab.cd".as_ptr().cast_mut().offset((2) as isize))
         as *mut libc::c_char)
         .cast_const();
@@ -69,7 +96,8 @@ unsafe fn main_0() -> i32 {
     assert!((((((*tail.offset((2) as isize)) as i32) == ('d' as i32)) as i32) != 0));
     let mut have: i32 = 0;
     let mut p: *mut ::libc::c_void = if (have != 0) {
-        (table_1[(0) as usize].name as *mut ::libc::c_void)
+        ((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize].name
+            as *mut ::libc::c_void)
     } else {
         (c"".as_ptr().cast_mut() as *mut libc::c_char as *mut ::libc::c_void)
     };
@@ -79,7 +107,8 @@ unsafe fn main_0() -> i32 {
     );
     have = 1;
     p = if (have != 0) {
-        (table_1[(0) as usize].name as *mut ::libc::c_void)
+        ((*std::cell::LazyCell::force_mut(&mut *&raw mut table_1))[(0) as usize].name
+            as *mut ::libc::c_void)
     } else {
         (c"".as_ptr().cast_mut() as *mut libc::c_char as *mut ::libc::c_void)
     };
diff --git a/tests/unit/out/unsafe/union_tagged_struct_arms.rs b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
index 95a0dee09..8ae914546 100644
--- a/tests/unit/out/unsafe/union_tagged_struct_arms.rs
+++ b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
@@ -59,17 +59,18 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    static mut items_4: [*mut libc::c_char; 3] = unsafe {
-        [
-            c"a".as_ptr().cast_mut(),
-            c"b".as_ptr().cast_mut(),
-            c"c".as_ptr().cast_mut(),
-        ]
-    };;
+    static mut items_4: std::cell::LazyCell<[*mut libc::c_char; 3]> =
+        std::cell::LazyCell::new(|| unsafe {
+            [
+                c"a".as_ptr().cast_mut(),
+                c"b".as_ptr().cast_mut(),
+                c"c".as_ptr().cast_mut(),
+            ]
+        });;
     let mut p_list: Branch = <Branch>::default();
     p_list.choice = Choice_enum_C_LIST;
     p_list.index = 0;
-    p_list.v.list.items = items_4.as_mut_ptr();
+    p_list.v.list.items = (*std::cell::LazyCell::force_mut(&mut *&raw mut items_4)).as_mut_ptr();
     p_list.v.list.count = 3_i64;
     p_list.v.list.cursor = 1_i64;
     assert!(((((p_list.v.list.count) == (3_i64)) as i32) != 0));
diff --git a/tests/unit/out/unsafe/void_cast.rs b/tests/unit/out/unsafe/void_cast.rs
index 0ce11d69d..79e223e59 100644
--- a/tests/unit/out/unsafe/void_cast.rs
+++ b/tests/unit/out/unsafe/void_cast.rs
@@ -20,10 +20,11 @@ pub unsafe fn unused_ref_param_1(x: *const NonTrivial) {
 pub unsafe fn unused_ptr_param_2(mut p: *const NonTrivial) {
     &(*p);
 }
-pub static mut side_effect_counter_3: i32 = unsafe { 0 };
+pub static mut side_effect_counter_3: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { 0 });
 pub unsafe fn bump_and_return_4() -> i32 {
-    side_effect_counter_3.prefix_inc();
-    return side_effect_counter_3;
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)).prefix_inc();
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3));
 }
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
@@ -61,12 +62,12 @@ unsafe fn main_0() -> i32 {
     assert!(((w) == (3)));
     assert!(((counter) == (3)));
     &(unsafe { bump_and_return_4() });
-    assert!(((side_effect_counter_3) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (1)));
     let mut v: i32 = {
         &(unsafe { bump_and_return_4() });
         99
     };
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     assert!(((v) == (99)));
     &(0);
     &(0);
@@ -83,13 +84,13 @@ unsafe fn main_0() -> i32 {
     assert!(((err) == (7)));
     assert!(((chosen) == (123)));
     &(bump_and_return_4);
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     &(Some(bump_and_return_4));
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     &(std::mem::transmute::<Option<unsafe fn() -> i32>, Option<unsafe fn() -> i32>>(
         (Some(bump_and_return_4)),
     ));
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     let mut storage: i32 = 11;
     let mut p: *mut i32 = (&mut storage as *mut i32);
     &(*p);

From 0aa238738323f1b6dfced006c403c162a1a63d68 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Mon, 14 Sep 2026 15:01:08 +0100
Subject: [PATCH 3/9] Use lazy initialization for statics

---
 cpp2rust/converter/converter.cpp               | 14 +++++++++++---
 cpp2rust/converter/converter.h                 |  5 ++++-
 cpp2rust/converter/lex.h                       |  2 ++
 cpp2rust/converter/models/converter_refcount.h |  1 +
 4 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index aae2337f7..76c20fb64 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -532,7 +532,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('>');
   }
@@ -597,8 +600,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);
   }
@@ -2860,7 +2864,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);
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index a5117fc7b..9f601de97 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -98,6 +98,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual bool VisitFunctionTemplateDecl(clang::FunctionTemplateDecl *decl);
 
   virtual bool VisitVarDecl(clang::VarDecl *decl);
+  virtual bool LazyStaticInit() const { return true; }
 
   void ConvertVarDecl(clang::VarDecl *decl);
 
@@ -464,7 +465,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;
 
@@ -489,6 +490,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
diff --git a/cpp2rust/converter/lex.h b/cpp2rust/converter/lex.h
index 207e70779..93b3b4a8d 100644
--- a/cpp2rust/converter/lex.h
+++ b/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 {
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index 818e06c94..28b95447f 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -79,6 +79,7 @@ class ConverterRefCount final : public Converter {
   void EmitFunctionPreamble(clang::FunctionDecl *decl) override;
 
   bool VisitVarDecl(clang::VarDecl *decl) override;
+  bool LazyStaticInit() const override { return false; }
 
   void ConvertGlobalVarDecl(clang::VarDecl *decl) override;
 

From e5731d995476105fb7d191884a70014b0e997e47 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Mon, 14 Sep 2026 15:17:34 +0100
Subject: [PATCH 4/9] Update tests

---
 tests/unit/global_init_side_effect.cpp        | 15 ++++++
 .../out/refcount/global_init_side_effect.rs   | 51 +++++++++++++++++++
 .../out/unsafe/global_init_side_effect.rs     | 30 +++++++++++
 3 files changed, 96 insertions(+)
 create mode 100644 tests/unit/global_init_side_effect.cpp
 create mode 100644 tests/unit/out/refcount/global_init_side_effect.rs
 create mode 100644 tests/unit/out/unsafe/global_init_side_effect.rs

diff --git a/tests/unit/global_init_side_effect.cpp b/tests/unit/global_init_side_effect.cpp
new file mode 100644
index 000000000..bf3919868
--- /dev/null
+++ b/tests/unit/global_init_side_effect.cpp
@@ -0,0 +1,15 @@
+#include <cassert>
+
+static int total = 0;
+
+struct S {
+  S(int x) { total += x; }
+};
+
+static S a(1);
+static S b(10);
+
+int main() {
+  assert(total == 11);
+  return 0;
+}
diff --git a/tests/unit/out/refcount/global_init_side_effect.rs b/tests/unit/out/refcount/global_init_side_effect.rs
new file mode 100644
index 000000000..3610845b0
--- /dev/null
+++ b/tests/unit/out/refcount/global_init_side_effect.rs
@@ -0,0 +1,51 @@
+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};
+thread_local!(
+    pub static total_0: Value<i32> = Rc::new(RefCell::new(0));
+);
+#[derive(Default)]
+pub struct S {}
+impl S {
+    pub fn S(x: i32) -> Self {
+        let x: Value<i32> = Rc::new(RefCell::new(x));
+        let __this: Value<S> = Rc::new(RefCell::new(Self {}));
+        let this: Ptr<S> = __this.as_pointer();
+        (*total_0.with(Value::clone).borrow_mut()) += (*x.borrow());
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl Clone for S {
+    fn clone(&self) -> Self {
+        let __this: Value<S> = Rc::new(RefCell::new(Self {}));
+        let this: Ptr<S> = __this.as_pointer();
+        Rc::try_unwrap(__this).ok().unwrap().into_inner()
+    }
+}
+impl ByteRepr for S {
+    fn byte_size() -> usize {
+        1
+    }
+    fn to_bytes(&self, buf: &mut [u8]) {}
+    fn from_bytes(buf: &[u8]) -> Self {
+        Self {}
+    }
+}
+thread_local!(
+    pub static a_1: Value<S> = Rc::new(RefCell::new(S::S({ 1 })));
+);
+thread_local!(
+    pub static b_2: Value<S> = Rc::new(RefCell::new(S::S({ 10 })));
+);
+pub fn main() {
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    assert!(((*total_0.with(Value::clone).borrow()) == 11));
+    return 0;
+}
diff --git a/tests/unit/out/unsafe/global_init_side_effect.rs b/tests/unit/out/unsafe/global_init_side_effect.rs
new file mode 100644
index 000000000..82b0ae944
--- /dev/null
+++ b/tests/unit/out/unsafe/global_init_side_effect.rs
@@ -0,0 +1,30 @@
+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;
+pub static mut total_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+#[repr(C)]
+#[derive(Copy, Clone, Default)]
+pub struct S {}
+impl S {
+    pub unsafe fn S(mut x: i32) -> Self {
+        let mut this = Self {};
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) += x;
+        this
+    }
+}
+pub static mut a_1: std::cell::LazyCell<S> = std::cell::LazyCell::new(|| unsafe { S::S({ 1 }) });
+pub static mut b_2: std::cell::LazyCell<S> = std::cell::LazyCell::new(|| unsafe { S::S({ 10 }) });
+pub fn main() {
+    unsafe {
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) == (11)));
+    return 0;
+}

From 442e534aac315519ed4b39c81ca03a971c5cbc6e Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Mon, 14 Sep 2026 15:51:09 +0100
Subject: [PATCH 5/9] Initialize global variables before starting main

---
 cpp2rust/converter/converter.cpp              | 26 ++++++++++++++++---
 cpp2rust/converter/converter.h                |  4 +++
 .../converter/models/converter_refcount.cpp   | 10 ++++++-
 .../converter/models/converter_refcount.h     |  1 +
 cpp2rust/cpp2rust_lib.cpp                     |  2 ++
 .../refcount/cross_tu_anon_enum_collision.rs  |  2 ++
 .../unsafe/cross_tu_anon_enum_collision.rs    |  2 ++
 .../out/refcount/cross_tu_tag_collision.rs    |  2 ++
 .../out/unsafe/cross_tu_tag_collision.rs      |  2 ++
 .../out/refcount/extern_functions.rs          |  2 ++
 .../out/unsafe/extern_functions.rs            |  2 ++
 .../out/refcount/header_function.rs           |  2 ++
 .../out/unsafe/header_function.rs             |  2 ++
 .../out/refcount/opaque_forward_decl.rs       |  2 ++
 .../out/unsafe/opaque_forward_decl.rs         |  2 ++
 .../out/refcount/static_name_collision.rs     |  7 +++++
 .../out/unsafe/static_name_collision.rs       |  7 +++++
 .../template_method_late_instantiation.rs     |  2 ++
 .../template_method_late_instantiation.rs     |  2 ++
 tests/ub/out/refcount/ctor_ref_member.rs      |  2 ++
 .../refcount/dangling-prvalue-as-lvalue.rs    |  2 ++
 .../ub/out/refcount/enum_out_of_range_cast.rs |  2 ++
 .../refcount/enum_out_of_range_increment.rs   |  2 ++
 tests/ub/out/refcount/fd_close_invalid.rs     |  2 ++
 tests/ub/out/refcount/fd_double_close.rs      |  2 ++
 tests/ub/out/refcount/fd_use_after_close.rs   |  2 ++
 .../ub/out/refcount/file_use_after_fclose.rs  |  2 ++
 tests/ub/out/refcount/max.rs                  |  2 ++
 tests/ub/out/refcount/ret_ref_to_local.rs     |  2 ++
 tests/ub/out/refcount/ub1.rs                  |  2 ++
 tests/ub/out/refcount/ub10.rs                 |  2 ++
 tests/ub/out/refcount/ub11.rs                 |  2 ++
 tests/ub/out/refcount/ub12.rs                 |  2 ++
 tests/ub/out/refcount/ub13.rs                 |  2 ++
 tests/ub/out/refcount/ub14.rs                 |  2 ++
 tests/ub/out/refcount/ub15.rs                 |  2 ++
 tests/ub/out/refcount/ub16.rs                 |  2 ++
 tests/ub/out/refcount/ub17.rs                 |  2 ++
 tests/ub/out/refcount/ub18.rs                 |  2 ++
 tests/ub/out/refcount/ub19.rs                 |  2 ++
 tests/ub/out/refcount/ub2.rs                  |  2 ++
 tests/ub/out/refcount/ub20.rs                 |  2 ++
 tests/ub/out/refcount/ub21.rs                 |  2 ++
 tests/ub/out/refcount/ub3.rs                  |  2 ++
 tests/ub/out/refcount/ub4.rs                  |  2 ++
 tests/ub/out/refcount/ub5.rs                  |  2 ++
 tests/ub/out/refcount/ub6.rs                  |  2 ++
 tests/ub/out/refcount/ub7.rs                  |  2 ++
 tests/ub/out/refcount/ub8.rs                  |  2 ++
 tests/ub/out/refcount/ub9.rs                  |  2 ++
 tests/ub/out/unsafe/ctor_ref_member.rs        |  2 ++
 .../out/unsafe/dangling-prvalue-as-lvalue.rs  |  2 ++
 tests/ub/out/unsafe/enum_out_of_range_cast.rs |  2 ++
 .../out/unsafe/enum_out_of_range_increment.rs |  2 ++
 tests/ub/out/unsafe/fd_close_invalid.rs       |  2 ++
 tests/ub/out/unsafe/fd_double_close.rs        |  2 ++
 tests/ub/out/unsafe/fd_use_after_close.rs     |  2 ++
 tests/ub/out/unsafe/file_use_after_fclose.rs  |  2 ++
 tests/ub/out/unsafe/max.rs                    |  2 ++
 tests/ub/out/unsafe/ret_ref_to_local.rs       |  2 ++
 tests/ub/out/unsafe/ub1.rs                    |  2 ++
 tests/ub/out/unsafe/ub10.rs                   |  2 ++
 tests/ub/out/unsafe/ub11.rs                   |  2 ++
 tests/ub/out/unsafe/ub12.rs                   |  2 ++
 tests/ub/out/unsafe/ub13.rs                   |  2 ++
 tests/ub/out/unsafe/ub14.rs                   |  2 ++
 tests/ub/out/unsafe/ub15.rs                   |  2 ++
 tests/ub/out/unsafe/ub16.rs                   |  2 ++
 tests/ub/out/unsafe/ub17.rs                   |  2 ++
 tests/ub/out/unsafe/ub18.rs                   |  2 ++
 tests/ub/out/unsafe/ub19.rs                   |  2 ++
 tests/ub/out/unsafe/ub2.rs                    |  2 ++
 tests/ub/out/unsafe/ub20.rs                   |  2 ++
 tests/ub/out/unsafe/ub21.rs                   |  2 ++
 tests/ub/out/unsafe/ub3.rs                    |  2 ++
 tests/ub/out/unsafe/ub4.rs                    |  2 ++
 tests/ub/out/unsafe/ub5.rs                    |  2 ++
 tests/ub/out/unsafe/ub6.rs                    |  2 ++
 tests/ub/out/unsafe/ub7.rs                    |  2 ++
 tests/ub/out/unsafe/ub8.rs                    |  2 ++
 tests/ub/out/unsafe/ub9.rs                    |  2 ++
 tests/unit/out/refcount/01_local.rs           |  2 ++
 tests/unit/out/refcount/02_address_taken.rs   |  2 ++
 tests/unit/out/refcount/03_local_array.rs     |  2 ++
 .../out/refcount/04_address_taken_array.rs    |  2 ++
 tests/unit/out/refcount/05_new.rs             |  2 ++
 tests/unit/out/refcount/06_new_array.rs       |  2 ++
 tests/unit/out/refcount/07_unique.rs          |  2 ++
 tests/unit/out/refcount/08_unique_array.rs    |  2 ++
 tests/unit/out/refcount/09_references.rs      |  2 ++
 tests/unit/out/refcount/10_struct.rs          |  2 ++
 tests/unit/out/refcount/11_move.rs            |  2 ++
 tests/unit/out/refcount/12_test.rs            |  2 ++
 tests/unit/out/refcount/13_testing.rs         |  2 ++
 tests/unit/out/refcount/14_testing2.rs        |  2 ++
 .../unit/out/refcount/__builtin_constant_p.rs |  2 ++
 tests/unit/out/refcount/addr_of_global.rs     |  8 ++++++
 tests/unit/out/refcount/alloc_array.rs        |  2 ++
 tests/unit/out/refcount/anonymous-struct.rs   |  2 ++
 tests/unit/out/refcount/anonymous-struct_c.rs |  2 ++
 tests/unit/out/refcount/anonymous_enum.rs     |  2 ++
 tests/unit/out/refcount/anonymous_enum_c.rs   |  2 ++
 tests/unit/out/refcount/array.rs              |  2 ++
 tests/unit/out/refcount/array_2d_default.rs   |  2 ++
 tests/unit/out/refcount/array_const_init.rs   |  4 +++
 .../out/refcount/array_of_noncopy_struct.rs   |  2 ++
 tests/unit/out/refcount/array_reference.rs    |  2 ++
 tests/unit/out/refcount/assert.rs             |  2 ++
 tests/unit/out/refcount/assign_as_value.rs    |  2 ++
 tests/unit/out/refcount/auto.rs               |  2 ++
 .../unit/out/refcount/bool_condition_enum.rs  |  2 ++
 .../out/refcount/bool_condition_enum_c.rs     |  2 ++
 tests/unit/out/refcount/bool_condition_int.rs |  2 ++
 .../unit/out/refcount/bool_condition_int_c.rs |  2 ++
 .../out/refcount/bool_condition_logical.rs    |  4 +++
 .../out/refcount/bool_condition_logical_c.rs  |  4 +++
 tests/unit/out/refcount/bool_condition_ptr.rs |  2 ++
 .../unit/out/refcount/bool_condition_ptr_c.rs |  2 ++
 tests/unit/out/refcount/bool_printing.rs      |  2 ++
 tests/unit/out/refcount/borrow_mut_opt.rs     |  2 ++
 tests/unit/out/refcount/bounded_struct_ptr.rs |  2 ++
 tests/unit/out/refcount/break.rs              |  2 ++
 tests/unit/out/refcount/bst.rs                |  2 ++
 tests/unit/out/refcount/builtin.rs            |  2 ++
 .../out/refcount/builtin_types_compatible.rs  |  2 ++
 tests/unit/out/refcount/byte.rs               |  2 ++
 tests/unit/out/refcount/c_struct.rs           |  2 ++
 tests/unit/out/refcount/cast.rs               |  2 ++
 .../refcount/cast_array_to_pointer_decay.rs   |  2 ++
 tests/unit/out/refcount/char_printing.rs      |  2 ++
 tests/unit/out/refcount/char_printing_cerr.rs |  2 ++
 tests/unit/out/refcount/class.rs              |  2 ++
 .../refcount/class_template_lazy_member.rs    |  2 ++
 tests/unit/out/refcount/class_templates.rs    |  2 ++
 tests/unit/out/refcount/clone_vs_move.rs      |  2 ++
 tests/unit/out/refcount/comma_operator.rs     |  2 ++
 tests/unit/out/refcount/complex_function.rs   |  2 ++
 .../out/refcount/compound_assign_paren.rs     |  2 ++
 .../unit/out/refcount/compound_assign_ref.rs  |  2 ++
 tests/unit/out/refcount/constexpr_function.rs |  2 ++
 tests/unit/out/refcount/constructor.rs        |  4 +++
 tests/unit/out/refcount/continue.rs           |  2 ++
 tests/unit/out/refcount/copy_assign.rs        |  4 +++
 tests/unit/out/refcount/copy_ctor.rs          |  4 +++
 tests/unit/out/refcount/cout_alias.rs         |  2 ++
 tests/unit/out/refcount/cstring.rs            |  2 ++
 tests/unit/out/refcount/default.rs            |  2 ++
 .../refcount/default_function_arguments.rs    |  2 ++
 tests/unit/out/refcount/default_in_statics.rs |  8 ++++++
 tests/unit/out/refcount/destructor.rs         |  6 +++++
 tests/unit/out/refcount/do_while_continue.rs  |  2 ++
 tests/unit/out/refcount/doubly_linked_list.rs |  2 ++
 tests/unit/out/refcount/dowhile.rs            |  2 ++
 tests/unit/out/refcount/empty_array_init.rs   |  2 ++
 tests/unit/out/refcount/empty_main.rs         |  2 ++
 .../refcount/enum_comparisson_in_globals.rs   |  4 +++
 .../out/refcount/enum_default_in_static.rs    |  4 +++
 tests/unit/out/refcount/enum_increment.rs     |  2 ++
 tests/unit/out/refcount/enum_int_interop.rs   |  7 +++++
 tests/unit/out/refcount/enum_int_interop_c.rs |  7 +++++
 .../refcount/enum_with_duplicated_values.rs   |  2 ++
 tests/unit/out/refcount/errno.rs              |  2 ++
 tests/unit/out/refcount/expr_as_bool_c.rs     |  2 ++
 tests/unit/out/refcount/expr_as_bool_cpp.rs   |  2 ++
 tests/unit/out/refcount/exprs.rs              |  2 ++
 tests/unit/out/refcount/fatorial.rs           |  2 ++
 tests/unit/out/refcount/fcall.rs              |  2 ++
 tests/unit/out/refcount/fcntl.rs              |  2 ++
 tests/unit/out/refcount/fd_io.rs              |  2 ++
 tests/unit/out/refcount/fd_set_macros.rs      |  2 ++
 tests/unit/out/refcount/fflush_null.rs        |  2 ++
 tests/unit/out/refcount/fft.rs                |  2 ++
 tests/unit/out/refcount/find.rs               |  2 ++
 tests/unit/out/refcount/fn_ptr.rs             |  2 ++
 tests/unit/out/refcount/fn_ptr_arity.rs       |  2 ++
 tests/unit/out/refcount/fn_ptr_array.rs       |  2 ++
 .../unit/out/refcount/fn_ptr_as_condition.rs  |  2 ++
 tests/unit/out/refcount/fn_ptr_cast.rs        |  2 ++
 tests/unit/out/refcount/fn_ptr_conditional.rs |  2 ++
 tests/unit/out/refcount/fn_ptr_default_arg.rs |  2 ++
 tests/unit/out/refcount/fn_ptr_global.rs      |  4 +++
 tests/unit/out/refcount/fn_ptr_reassign.rs    |  2 ++
 tests/unit/out/refcount/fn_ptr_return.rs      |  2 ++
 tests/unit/out/refcount/fn_ptr_stable_sort.rs |  2 ++
 .../out/refcount/fn_ptr_stdlib_compare.rs     |  2 ++
 tests/unit/out/refcount/fn_ptr_struct.rs      |  2 ++
 tests/unit/out/refcount/fn_ptr_void_return.rs |  2 ++
 tests/unit/out/refcount/fn_ptr_vtable.rs      |  4 +++
 tests/unit/out/refcount/fopen.rs              |  2 ++
 tests/unit/out/refcount/foreach.rs            |  2 ++
 .../refcount/foreach_disjoint_field_borrow.rs |  2 ++
 tests/unit/out/refcount/foreach_double.rs     |  2 ++
 tests/unit/out/refcount/foreach_map.rs        |  2 ++
 tests/unit/out/refcount/foreach_mut.rs        |  2 ++
 tests/unit/out/refcount/friend.rs             |  2 ++
 tests/unit/out/refcount/fstat.rs              |  2 ++
 tests/unit/out/refcount/function_call.rs      |  2 ++
 .../unit/out/refcount/function_overloading.rs |  2 ++
 .../global-initialization-using-global.rs     |  5 ++++
 .../out/refcount/global_init_side_effect.rs   |  6 +++++
 .../out/refcount/global_non_const_init.rs     | 12 +++++++++
 tests/unit/out/refcount/global_pointers.rs    |  6 +++++
 .../refcount/global_without_initializer.rs    |  6 +++++
 .../out/refcount/goto_aggregate_default.rs    |  2 ++
 tests/unit/out/refcount/goto_backward.rs      |  2 ++
 tests/unit/out/refcount/goto_cleanup.rs       |  2 ++
 tests/unit/out/refcount/goto_loop_control.rs  |  2 ++
 tests/unit/out/refcount/goto_multi_label.rs   |  2 ++
 tests/unit/out/refcount/goto_nested_label.rs  |  2 ++
 .../out/refcount/goto_switch_fallthrough.rs   |  2 ++
 .../out/refcount/goto_switch_self_case.rs     |  2 ++
 tests/unit/out/refcount/huffman.rs            |  2 ++
 tests/unit/out/refcount/ifaddrs.rs            |  2 ++
 tests/unit/out/refcount/ignored_rule.rs       |  2 ++
 .../refcount/immutable-deref-on-func-call.rs  |  2 ++
 .../refcount/immutable_unsigned_arithmetic.rs |  2 ++
 tests/unit/out/refcount/implicit_autoref.rs   |  2 ++
 tests/unit/out/refcount/implicit_ptr_cast.rs  |  2 ++
 tests/unit/out/refcount/inet_pton_ntop.rs     |  2 ++
 tests/unit/out/refcount/init.rs               |  2 ++
 tests/unit/out/refcount/init_list.rs          |  2 ++
 tests/unit/out/refcount/initializer_list.rs   |  2 ++
 .../unit/out/refcount/int_to_bool_explicit.rs |  2 ++
 .../out/refcount/int_to_bool_explicit_c.rs    |  2 ++
 tests/unit/out/refcount/ipproto_macros.rs     |  2 ++
 tests/unit/out/refcount/isatty.rs             |  2 ++
 tests/unit/out/refcount/iterator_freshness.rs |  2 ++
 tests/unit/out/refcount/iterators.rs          |  2 ++
 tests/unit/out/refcount/keywords.rs           |  2 ++
 tests/unit/out/refcount/kruskal.rs            |  2 ++
 .../unit/out/refcount/lambda_capture_pass.rs  |  2 ++
 tests/unit/out/refcount/lambda_nested.rs      |  2 ++
 .../unit/out/refcount/libc_char_ptr_field.rs  |  2 ++
 .../refcount/libc_struct_without_default.rs   |  2 ++
 tests/unit/out/refcount/linked_list.rs        |  2 ++
 .../refcount/local_anon_struct_collision.rs   |  2 ++
 .../out/refcount/loop_with_postfix_inc.rs     |  2 ++
 tests/unit/out/refcount/lseek_ftruncate.rs    |  2 ++
 tests/unit/out/refcount/lvalue_ref_goto.rs    |  2 ++
 tests/unit/out/refcount/macros.rs             |  2 ++
 tests/unit/out/refcount/main.rs               |  2 ++
 .../unit/out/refcount/malloc_realloc_free.rs  |  2 ++
 tests/unit/out/refcount/map-reallocation.rs   |  2 ++
 tests/unit/out/refcount/map.rs                |  2 ++
 tests/unit/out/refcount/matmul.rs             |  2 ++
 tests/unit/out/refcount/max.rs                |  2 ++
 tests/unit/out/refcount/memcpy_overlap.rs     |  2 ++
 .../unit/out/refcount/memcpy_struct_bytes.rs  |  2 ++
 .../unit/out/refcount/memcpy_struct_struct.rs |  2 ++
 tests/unit/out/refcount/memset.rs             |  2 ++
 tests/unit/out/refcount/min_max_ptr2ptr.rs    |  2 ++
 tests/unit/out/refcount/move_assign.rs        |  2 ++
 tests/unit/out/refcount/move_ctor.rs          |  2 ++
 tests/unit/out/refcount/move_this.rs          |  2 ++
 tests/unit/out/refcount/nested_block_scope.rs |  2 ++
 tests/unit/out/refcount/nested_structs.rs     |  2 ++
 tests/unit/out/refcount/netdb.rs              |  2 ++
 tests/unit/out/refcount/new.rs                |  2 ++
 tests/unit/out/refcount/new_alloc_array.rs    |  2 ++
 tests/unit/out/refcount/new_array.rs          |  2 ++
 tests/unit/out/refcount/new_array_var_size.rs |  2 ++
 tests/unit/out/refcount/new_bst.rs            |  2 ++
 tests/unit/out/refcount/new_struct.rs         |  2 ++
 tests/unit/out/refcount/no_direct_callee.rs   |  2 ++
 tests/unit/out/refcount/null_compare.rs       |  2 ++
 tests/unit/out/refcount/null_in_statics.rs    | 11 ++++++++
 tests/unit/out/refcount/offsetof.rs           |  2 ++
 .../unit/out/refcount/opaque_forward_decl.rs  |  2 ++
 tests/unit/out/refcount/opaque_record_copy.rs |  2 ++
 .../unit/out/refcount/opaque_then_defined.rs  |  2 ++
 .../out/refcount/operator_arithmetic_free.rs  |  2 ++
 .../refcount/operator_arithmetic_member.rs    |  2 ++
 .../out/refcount/operator_bitwise_free.rs     |  2 ++
 .../out/refcount/operator_bitwise_member.rs   |  2 ++
 .../refcount/operator_comparison_defaulted.rs |  2 ++
 .../out/refcount/operator_comparison_free.rs  |  2 ++
 .../refcount/operator_comparison_member.rs    |  2 ++
 .../out/refcount/operator_comparison_mixed.rs |  2 ++
 .../operator_comparison_noncopyable.rs        |  2 ++
 .../operator_compound_assignment_free.rs      |  2 ++
 .../operator_compound_assignment_member.rs    |  2 ++
 tests/unit/out/refcount/operator_less_than.rs |  2 ++
 .../out/refcount/operator_logical_free.rs     |  2 ++
 .../out/refcount/operator_logical_member.rs   |  2 ++
 .../refcount/operator_member_pointer_free.rs  |  2 ++
 .../operator_member_pointer_member.rs         |  4 +++
 .../unit/out/refcount/operator_other_free.rs  |  2 ++
 .../out/refcount/operator_other_member.rs     |  2 ++
 tests/unit/out/refcount/operator_overloads.rs |  2 ++
 .../unit/out/refcount/operator_qualifiers.rs  |  2 ++
 tests/unit/out/refcount/operator_synonyms.rs  |  2 ++
 tests/unit/out/refcount/operator_three_way.rs |  2 ++
 tests/unit/out/refcount/operator_traits.rs    |  2 ++
 tests/unit/out/refcount/overload_mangling.rs  |  2 ++
 tests/unit/out/refcount/pair.rs               |  2 ++
 tests/unit/out/refcount/pipe_io.rs            |  2 ++
 tests/unit/out/refcount/pod.rs                |  2 ++
 tests/unit/out/refcount/pointer_add_assign.rs |  2 ++
 tests/unit/out/refcount/pointer_arithmetic.rs |  2 ++
 tests/unit/out/refcount/pointer_array.rs      |  2 ++
 .../unit/out/refcount/pointer_call_offset.rs  |  2 ++
 tests/unit/out/refcount/pointer_diff.rs       |  2 ++
 tests/unit/out/refcount/pointer_eq.rs         |  2 ++
 tests/unit/out/refcount/pointer_neq.rs        |  2 ++
 tests/unit/out/refcount/pointer_offset.rs     |  2 ++
 tests/unit/out/refcount/pointer_printf.rs     |  2 ++
 tests/unit/out/refcount/pointer_to_boolean.rs |  2 ++
 .../unit/out/refcount/pointer_usize_arith.rs  |  2 ++
 tests/unit/out/refcount/pointers.rs           |  2 ++
 tests/unit/out/refcount/poll.rs               |  2 ++
 tests/unit/out/refcount/polymorphism.rs       |  2 ++
 tests/unit/out/refcount/printfs.rs            |  2 ++
 tests/unit/out/refcount/prvalue-as-lvalue.rs  |  2 ++
 tests/unit/out/refcount/ptr2ptr.rs            |  2 ++
 tests/unit/out/refcount/ptr_cast_init.rs      |  2 ++
 .../out/refcount/ptr_to_incomplete_struct.rs  |  2 ++
 tests/unit/out/refcount/push_emplace_back.rs  |  2 ++
 tests/unit/out/refcount/pwd.rs                |  2 ++
 tests/unit/out/refcount/qsort_bsearch.rs      |  2 ++
 tests/unit/out/refcount/random.rs             |  2 ++
 tests/unit/out/refcount/rebind.rs             |  2 ++
 .../refcount/redundant_copy_in_conversion.rs  |  2 ++
 tests/unit/out/refcount/ref_calls.rs          |  2 ++
 tests/unit/out/refcount/reference_wrapper.rs  |  2 ++
 tests/unit/out/refcount/references.rs         |  2 ++
 tests/unit/out/refcount/references2.rs        |  2 ++
 tests/unit/out/refcount/refs_as_args.rs       |  2 ++
 tests/unit/out/refcount/reinterpret_cast.rs   |  2 ++
 .../out/refcount/reinterpret_cast_aliased.rs  |  2 ++
 .../refcount/reinterpret_cast_array_write.rs  |  2 ++
 .../out/refcount/reinterpret_cast_chain.rs    |  2 ++
 .../out/refcount/reinterpret_cast_double.rs   |  2 ++
 .../refcount/reinterpret_cast_empty_vec.rs    |  2 ++
 .../out/refcount/reinterpret_cast_float.rs    |  2 ++
 .../out/refcount/reinterpret_cast_i16_u16.rs  |  2 ++
 .../out/refcount/reinterpret_cast_identity.rs |  2 ++
 .../out/refcount/reinterpret_cast_iterate.rs  |  2 ++
 .../refcount/reinterpret_cast_large_array.rs  |  2 ++
 .../unit/out/refcount/reinterpret_cast_new.rs |  2 ++
 .../refcount/reinterpret_cast_new_array.rs    |  2 ++
 .../out/refcount/reinterpret_cast_oob_read.rs |  2 ++
 .../refcount/reinterpret_cast_oob_write.rs    |  2 ++
 .../reinterpret_cast_partial_overlap.rs       |  2 ++
 .../refcount/reinterpret_cast_roundtrip.rs    |  2 ++
 .../refcount/reinterpret_cast_same_type.rs    |  2 ++
 .../out/refcount/reinterpret_cast_signed.rs   |  2 ++
 .../out/refcount/reinterpret_cast_string.rs   |  2 ++
 .../out/refcount/reinterpret_cast_struct.rs   |  2 ++
 .../reinterpret_cast_struct_to_struct.rs      |  2 ++
 .../refcount/reinterpret_cast_u32_from_u8.rs  |  2 ++
 .../refcount/reinterpret_cast_undersize.rs    |  2 ++
 .../refcount/reinterpret_cast_vec_write.rs    |  2 ++
 .../refcount/reinterpret_cast_zero_init.rs    |  2 ++
 tests/unit/out/refcount/reserved_keywords.rs  |  2 ++
 tests/unit/out/refcount/ret_rvalue_ref.rs     |  2 ++
 tests/unit/out/refcount/rule_of_five.rs       |  6 +++++
 tests/unit/out/refcount/rule_of_three.rs      |  5 ++++
 tests/unit/out/refcount/rvalue_ref_general.rs |  2 ++
 tests/unit/out/refcount/rvalue_ref_global.rs  |  4 +++
 tests/unit/out/refcount/rvalue_ref_goto.rs    |  2 ++
 tests/unit/out/refcount/rvalue_struct.rs      |  2 ++
 .../scalar_builtin_construct_destruct.rs      |  2 ++
 tests/unit/out/refcount/select.rs             |  2 ++
 tests/unit/out/refcount/simple_function.rs    |  2 ++
 tests/unit/out/refcount/simple_index.rs       |  2 ++
 tests/unit/out/refcount/size_t_ssize_t.rs     |  2 ++
 tests/unit/out/refcount/snprintf.rs           |  2 ++
 tests/unit/out/refcount/socket_listen.rs      |  2 ++
 tests/unit/out/refcount/socket_open_close.rs  |  2 ++
 .../out/refcount/socket_transparent_union.rs  |  2 ++
 .../out/refcount/socket_type_constants.rs     |  2 ++
 tests/unit/out/refcount/sockopt.rs            |  2 ++
 tests/unit/out/refcount/sort.rs               |  2 ++
 .../refcount/split_binop_aliased_borrows.rs   |  2 ++
 tests/unit/out/refcount/stable_sort.rs        |  2 ++
 .../static_function_vars_same_name.rs         |  2 ++
 tests/unit/out/refcount/static_local.rs       |  2 ++
 tests/unit/out/refcount/static_shadow.rs      |  4 +++
 .../unit/out/refcount/static_var_in_class.rs  |  5 ++++
 tests/unit/out/refcount/stdcopy.rs            |  2 ++
 tests/unit/out/refcount/stdcopy_ostream.rs    |  2 ++
 tests/unit/out/refcount/stdio.rs              |  2 ++
 tests/unit/out/refcount/stdio_nofd.rs         |  2 ++
 tests/unit/out/refcount/stdmin_fpoint.rs      |  2 ++
 tests/unit/out/refcount/stmt_expr.rs          |  2 ++
 tests/unit/out/refcount/strdup.rs             |  2 ++
 tests/unit/out/refcount/string.rs             |  2 ++
 tests/unit/out/refcount/string2.rs            |  2 ++
 tests/unit/out/refcount/string_escape.rs      |  2 ++
 tests/unit/out/refcount/string_h.rs           |  2 ++
 .../refcount/string_literal_interior_null.rs  |  4 +++
 .../out/refcount/string_literal_ptr_init.rs   |  4 +++
 tests/unit/out/refcount/string_literals.rs    |  2 ++
 tests/unit/out/refcount/string_literals_c.rs  |  2 ++
 .../out/refcount/string_literals_concat.rs    |  2 ++
 .../out/refcount/string_literals_concat_c.rs  |  2 ++
 .../out/refcount/string_literals_return.rs    |  2 ++
 .../out/refcount/string_literals_return_c.rs  |  2 ++
 .../out/refcount/string_literals_sized.rs     |  2 ++
 .../out/refcount/string_literals_sized_c.rs   |  2 ++
 tests/unit/out/refcount/strlen.rs             |  2 ++
 tests/unit/out/refcount/strlen_diff.rs        |  2 ++
 tests/unit/out/refcount/strlen_rec.rs         |  2 ++
 tests/unit/out/refcount/struct_ctor.rs        |  2 ++
 .../unit/out/refcount/struct_default_ctor.rs  |  2 ++
 tests/unit/out/refcount/struct_ptr.rs         |  2 ++
 tests/unit/out/refcount/swap.rs               |  2 ++
 tests/unit/out/refcount/swap_extended.rs      |  2 ++
 tests/unit/out/refcount/switch_basic.rs       |  2 ++
 .../switch_borrow_in_condition_and_in_body.rs |  2 ++
 .../out/refcount/switch_case_then_default.rs  |  2 ++
 .../switch_cases_and_default_stacked.rs       |  2 ++
 tests/unit/out/refcount/switch_char.rs        |  2 ++
 .../unit/out/refcount/switch_complex_cond.rs  |  2 ++
 .../out/refcount/switch_compound_case_body.rs |  2 ++
 .../refcount/switch_continue_inside_switch.rs |  2 ++
 .../unit/out/refcount/switch_default_first.rs |  2 ++
 .../out/refcount/switch_default_middle.rs     |  2 ++
 .../out/refcount/switch_default_then_case.rs  |  2 ++
 .../refcount/switch_empty_case_with_break.rs  |  2 ++
 .../unit/out/refcount/switch_empty_switch.rs  |  2 ++
 tests/unit/out/refcount/switch_enum.rs        |  2 ++
 .../out/refcount/switch_fallthrough_chain.rs  |  2 ++
 .../refcount/switch_fallthrough_default.rs    |  2 ++
 .../refcount/switch_fallthrough_into_block.rs |  2 ++
 .../out/refcount/switch_fallthrough_one.rs    |  2 ++
 .../refcount/switch_for_in_switch_break.rs    |  2 ++
 .../refcount/switch_for_in_switch_continue.rs |  2 ++
 .../refcount/switch_for_switch_for_break.rs   |  2 ++
 tests/unit/out/refcount/switch_in_dowhile.rs  |  2 ++
 tests/unit/out/refcount/switch_in_loop.rs     |  2 ++
 .../refcount/switch_mixed_literal_cases.rs    |  2 ++
 .../out/refcount/switch_mixed_return_break.rs |  2 ++
 tests/unit/out/refcount/switch_nested.rs      |  2 ++
 tests/unit/out/refcount/switch_no_default.rs  |  2 ++
 .../unit/out/refcount/switch_on_assignment.rs |  2 ++
 tests/unit/out/refcount/switch_on_call.rs     |  2 ++
 .../unit/out/refcount/switch_only_default.rs  |  2 ++
 tests/unit/out/refcount/switch_stacked.rs     |  2 ++
 .../unit/out/refcount/switch_stacked_block.rs |  2 ++
 .../switch_stacked_with_inner_fallthrough.rs  |  2 ++
 .../refcount/switch_while_in_switch_break.rs  |  2 ++
 tests/unit/out/refcount/sys_stat.rs           |  2 ++
 tests/unit/out/refcount/sys_time.rs           |  2 ++
 .../refcount/tag_vs_identifier_collision.rs   |  2 ++
 tests/unit/out/refcount/template_pack.rs      |  2 ++
 tests/unit/out/refcount/templates.rs          |  2 ++
 tests/unit/out/refcount/termios.rs            |  2 ++
 tests/unit/out/refcount/this.rs               |  2 ++
 .../unit/out/refcount/typedef-anon-struct.rs  |  2 ++
 tests/unit/out/refcount/types.rs              |  2 ++
 tests/unit/out/refcount/unary.rs              |  2 ++
 .../out/refcount/unary_expr_or_type_trait.rs  |  2 ++
 tests/unit/out/refcount/unconst.rs            |  2 ++
 .../out/refcount/union_addrof_external.rs     |  2 ++
 tests/unit/out/refcount/union_basic.rs        |  2 ++
 .../unit/out/refcount/union_cross_arm_cast.rs |  2 ++
 .../out/refcount/union_field_alignment.rs     |  2 ++
 .../out/refcount/union_flex_array_member.rs   |  2 ++
 .../unit/out/refcount/union_memset_memcpy.rs  |  2 ++
 tests/unit/out/refcount/union_nested.rs       |  2 ++
 .../out/refcount/union_pointer_pun_address.rs |  2 ++
 .../union_pointer_pun_writethrough.rs         |  2 ++
 .../out/refcount/union_struct_dual_use.rs     |  2 ++
 .../out/refcount/union_tagged_many_arms.rs    |  2 ++
 .../unit/out/refcount/union_tagged_simple.rs  |  2 ++
 .../out/refcount/union_tagged_struct_arms.rs  |  2 ++
 .../refcount/union_void_ptr_sized_deref.rs    |  2 ++
 tests/unit/out/refcount/unique_ptr.rs         |  2 ++
 .../out/refcount/unique_ptr_const_deref.rs    |  2 ++
 .../unit/out/refcount/unique_ptr_deref_ops.rs |  2 ++
 tests/unit/out/refcount/unique_ptr_nested.rs  |  2 ++
 tests/unit/out/refcount/unique_ptr_small.rs   |  2 ++
 tests/unit/out/refcount/unique_ptr_struct.rs  |  2 ++
 tests/unit/out/refcount/unsigned.rs           |  2 ++
 .../out/refcount/user_defined_same_as_libc.rs |  2 ++
 tests/unit/out/refcount/va_arg_chain.rs       |  2 ++
 tests/unit/out/refcount/va_arg_concat.rs      |  2 ++
 tests/unit/out/refcount/va_arg_conditional.rs |  2 ++
 tests/unit/out/refcount/va_arg_copy.rs        |  2 ++
 tests/unit/out/refcount/va_arg_fn_ptr.rs      |  2 ++
 tests/unit/out/refcount/va_arg_forward.rs     |  2 ++
 .../unit/out/refcount/va_arg_mixed_int_ptr.rs |  2 ++
 tests/unit/out/refcount/va_arg_mixed_types.rs |  2 ++
 .../out/refcount/va_arg_non_primitive_ptrs.rs |  2 ++
 .../unit/out/refcount/va_arg_null_int_ptr.rs  |  2 ++
 tests/unit/out/refcount/va_arg_printf.rs      |  2 ++
 tests/unit/out/refcount/va_arg_promotion.rs   |  2 ++
 tests/unit/out/refcount/va_arg_snprintf.rs    |  2 ++
 tests/unit/out/refcount/va_arg_struct_ctx.rs  |  2 ++
 tests/unit/out/refcount/va_arg_two_passes.rs  |  2 ++
 tests/unit/out/refcount/va_arg_void_ptr.rs    |  2 ++
 tests/unit/out/refcount/vector.rs             |  2 ++
 tests/unit/out/refcount/vector2.rs            |  2 ++
 tests/unit/out/refcount/vector3.rs            |  2 ++
 .../unit/out/refcount/vector_addr_of_back.rs  |  2 ++
 .../out/refcount/vector_iter_range_ctor.rs    |  2 ++
 .../out/refcount/vector_with_allocator.rs     |  2 ++
 tests/unit/out/refcount/void_cast.rs          |  4 +++
 .../refcount/void_ptr_implicit_conversion.rs  |  2 ++
 tests/unit/out/refcount/void_return.rs        |  2 ++
 tests/unit/out/refcount/void_round_trip.rs    |  2 ++
 tests/unit/out/refcount/z_bit_cast.rs         |  2 ++
 tests/unit/out/unsafe/01_local.rs             |  2 ++
 tests/unit/out/unsafe/02_address_taken.rs     |  2 ++
 tests/unit/out/unsafe/03_local_array.rs       |  2 ++
 .../unit/out/unsafe/04_address_taken_array.rs |  2 ++
 tests/unit/out/unsafe/05_new.rs               |  2 ++
 tests/unit/out/unsafe/06_new_array.rs         |  2 ++
 tests/unit/out/unsafe/07_unique.rs            |  2 ++
 tests/unit/out/unsafe/08_unique_array.rs      |  2 ++
 tests/unit/out/unsafe/09_references.rs        |  2 ++
 tests/unit/out/unsafe/10_struct.rs            |  2 ++
 tests/unit/out/unsafe/11_move.rs              |  2 ++
 tests/unit/out/unsafe/12_test.rs              |  2 ++
 tests/unit/out/unsafe/13_testing.rs           |  2 ++
 tests/unit/out/unsafe/14_testing2.rs          |  2 ++
 tests/unit/out/unsafe/__builtin_constant_p.rs |  2 ++
 tests/unit/out/unsafe/addr_of_global.rs       |  8 ++++++
 tests/unit/out/unsafe/alloc_array.rs          |  2 ++
 tests/unit/out/unsafe/anonymous-struct.rs     |  2 ++
 tests/unit/out/unsafe/anonymous-struct_c.rs   |  2 ++
 tests/unit/out/unsafe/anonymous_enum.rs       |  2 ++
 tests/unit/out/unsafe/anonymous_enum_c.rs     |  2 ++
 tests/unit/out/unsafe/array.rs                |  2 ++
 tests/unit/out/unsafe/array_2d_default.rs     |  2 ++
 tests/unit/out/unsafe/array_const_init.rs     |  4 +++
 .../out/unsafe/array_of_noncopy_struct.rs     |  2 ++
 tests/unit/out/unsafe/array_reference.rs      |  2 ++
 tests/unit/out/unsafe/assert.rs               |  2 ++
 tests/unit/out/unsafe/assign_as_value.rs      |  2 ++
 tests/unit/out/unsafe/auto.rs                 |  2 ++
 tests/unit/out/unsafe/bool_condition_enum.rs  |  2 ++
 .../unit/out/unsafe/bool_condition_enum_c.rs  |  2 ++
 tests/unit/out/unsafe/bool_condition_int.rs   |  2 ++
 tests/unit/out/unsafe/bool_condition_int_c.rs |  2 ++
 .../unit/out/unsafe/bool_condition_logical.rs |  4 +++
 .../out/unsafe/bool_condition_logical_c.rs    |  4 +++
 tests/unit/out/unsafe/bool_condition_ptr.rs   |  2 ++
 tests/unit/out/unsafe/bool_condition_ptr_c.rs |  2 ++
 tests/unit/out/unsafe/bool_printing.rs        |  2 ++
 tests/unit/out/unsafe/borrow_mut_opt.rs       |  2 ++
 tests/unit/out/unsafe/bounded_struct_ptr.rs   |  2 ++
 tests/unit/out/unsafe/break.rs                |  2 ++
 tests/unit/out/unsafe/bst.rs                  |  2 ++
 tests/unit/out/unsafe/builtin.rs              |  2 ++
 .../out/unsafe/builtin_types_compatible.rs    |  2 ++
 tests/unit/out/unsafe/byte.rs                 |  2 ++
 tests/unit/out/unsafe/c_struct.rs             |  2 ++
 tests/unit/out/unsafe/cast.rs                 |  2 ++
 .../out/unsafe/cast_array_to_pointer_decay.rs |  2 ++
 tests/unit/out/unsafe/char_printing.rs        |  2 ++
 tests/unit/out/unsafe/char_printing_cerr.rs   |  2 ++
 tests/unit/out/unsafe/class.rs                |  2 ++
 .../out/unsafe/class_template_lazy_member.rs  |  2 ++
 tests/unit/out/unsafe/class_templates.rs      |  2 ++
 tests/unit/out/unsafe/clone_vs_move.rs        |  2 ++
 tests/unit/out/unsafe/comma_operator.rs       |  2 ++
 tests/unit/out/unsafe/complex_function.rs     |  2 ++
 .../unit/out/unsafe/compound_assign_paren.rs  |  2 ++
 tests/unit/out/unsafe/compound_assign_ref.rs  |  2 ++
 tests/unit/out/unsafe/constexpr_function.rs   |  2 ++
 tests/unit/out/unsafe/constructor.rs          |  4 +++
 tests/unit/out/unsafe/continue.rs             |  2 ++
 tests/unit/out/unsafe/copy_assign.rs          |  4 +++
 tests/unit/out/unsafe/copy_ctor.rs            |  4 +++
 tests/unit/out/unsafe/cout_alias.rs           |  2 ++
 tests/unit/out/unsafe/cstring.rs              |  2 ++
 tests/unit/out/unsafe/default.rs              |  2 ++
 .../out/unsafe/default_function_arguments.rs  |  2 ++
 tests/unit/out/unsafe/default_in_statics.rs   |  8 ++++++
 tests/unit/out/unsafe/destructor.rs           |  6 +++++
 tests/unit/out/unsafe/do_while_continue.rs    |  2 ++
 tests/unit/out/unsafe/doubly_linked_list.rs   |  2 ++
 tests/unit/out/unsafe/dowhile.rs              |  2 ++
 tests/unit/out/unsafe/empty_array_init.rs     |  2 ++
 tests/unit/out/unsafe/empty_main.rs           |  6 ++++-
 .../out/unsafe/enum_comparisson_in_globals.rs |  4 +++
 .../unit/out/unsafe/enum_default_in_static.rs |  4 +++
 tests/unit/out/unsafe/enum_increment.rs       |  2 ++
 tests/unit/out/unsafe/enum_int_interop.rs     |  7 +++++
 tests/unit/out/unsafe/enum_int_interop_c.rs   |  7 +++++
 .../out/unsafe/enum_with_duplicated_values.rs |  2 ++
 tests/unit/out/unsafe/errno.rs                |  2 ++
 tests/unit/out/unsafe/expr_as_bool_c.rs       |  2 ++
 tests/unit/out/unsafe/expr_as_bool_cpp.rs     |  2 ++
 tests/unit/out/unsafe/exprs.rs                |  2 ++
 tests/unit/out/unsafe/fatorial.rs             |  2 ++
 tests/unit/out/unsafe/fcall.rs                |  2 ++
 tests/unit/out/unsafe/fcntl.rs                |  2 ++
 tests/unit/out/unsafe/fd_io.rs                |  2 ++
 tests/unit/out/unsafe/fd_set_macros.rs        |  2 ++
 tests/unit/out/unsafe/fflush_null.rs          |  2 ++
 tests/unit/out/unsafe/fft.rs                  |  2 ++
 tests/unit/out/unsafe/find.rs                 |  2 ++
 tests/unit/out/unsafe/fn_ptr.rs               |  2 ++
 tests/unit/out/unsafe/fn_ptr_arity.rs         |  2 ++
 tests/unit/out/unsafe/fn_ptr_array.rs         |  2 ++
 tests/unit/out/unsafe/fn_ptr_as_condition.rs  |  2 ++
 tests/unit/out/unsafe/fn_ptr_cast.rs          |  2 ++
 tests/unit/out/unsafe/fn_ptr_conditional.rs   |  2 ++
 tests/unit/out/unsafe/fn_ptr_default_arg.rs   |  2 ++
 tests/unit/out/unsafe/fn_ptr_global.rs        |  4 +++
 tests/unit/out/unsafe/fn_ptr_reassign.rs      |  2 ++
 tests/unit/out/unsafe/fn_ptr_return.rs        |  2 ++
 tests/unit/out/unsafe/fn_ptr_stable_sort.rs   |  2 ++
 .../unit/out/unsafe/fn_ptr_stdlib_compare.rs  |  2 ++
 tests/unit/out/unsafe/fn_ptr_struct.rs        |  2 ++
 tests/unit/out/unsafe/fn_ptr_void_return.rs   |  2 ++
 tests/unit/out/unsafe/fn_ptr_vtable.rs        |  4 +++
 tests/unit/out/unsafe/fopen.rs                |  2 ++
 tests/unit/out/unsafe/foreach.rs              |  2 ++
 .../unsafe/foreach_disjoint_field_borrow.rs   |  2 ++
 tests/unit/out/unsafe/foreach_double.rs       |  2 ++
 tests/unit/out/unsafe/foreach_map.rs          |  2 ++
 tests/unit/out/unsafe/foreach_mut.rs          |  2 ++
 tests/unit/out/unsafe/friend.rs               |  2 ++
 tests/unit/out/unsafe/fstat.rs                |  2 ++
 tests/unit/out/unsafe/function_call.rs        |  2 ++
 tests/unit/out/unsafe/function_overloading.rs |  2 ++
 .../global-initialization-using-global.rs     |  5 ++++
 .../out/unsafe/global_init_side_effect.rs     |  6 +++++
 .../unit/out/unsafe/global_non_const_init.rs  | 12 +++++++++
 tests/unit/out/unsafe/global_pointers.rs      |  6 +++++
 .../out/unsafe/global_without_initializer.rs  |  6 +++++
 .../unit/out/unsafe/goto_aggregate_default.rs |  2 ++
 tests/unit/out/unsafe/goto_backward.rs        |  2 ++
 tests/unit/out/unsafe/goto_cleanup.rs         |  2 ++
 tests/unit/out/unsafe/goto_loop_control.rs    |  2 ++
 tests/unit/out/unsafe/goto_multi_label.rs     |  2 ++
 tests/unit/out/unsafe/goto_nested_label.rs    |  2 ++
 .../out/unsafe/goto_switch_fallthrough.rs     |  2 ++
 .../unit/out/unsafe/goto_switch_self_case.rs  |  2 ++
 tests/unit/out/unsafe/huffman.rs              |  2 ++
 tests/unit/out/unsafe/ifaddrs.rs              |  2 ++
 tests/unit/out/unsafe/ignored_rule.rs         |  2 ++
 .../unsafe/immutable-deref-on-func-call.rs    |  2 ++
 .../unsafe/immutable_unsigned_arithmetic.rs   |  2 ++
 tests/unit/out/unsafe/implicit_autoref.rs     |  2 ++
 tests/unit/out/unsafe/implicit_ptr_cast.rs    |  2 ++
 tests/unit/out/unsafe/inet_pton_ntop.rs       |  2 ++
 tests/unit/out/unsafe/init.rs                 |  2 ++
 tests/unit/out/unsafe/init_list.rs            |  2 ++
 tests/unit/out/unsafe/initializer_list.rs     |  2 ++
 tests/unit/out/unsafe/int_to_bool_explicit.rs |  2 ++
 .../unit/out/unsafe/int_to_bool_explicit_c.rs |  2 ++
 tests/unit/out/unsafe/ipproto_macros.rs       |  2 ++
 tests/unit/out/unsafe/isatty.rs               |  2 ++
 tests/unit/out/unsafe/iterator_freshness.rs   |  2 ++
 tests/unit/out/unsafe/iterators.rs            |  2 ++
 tests/unit/out/unsafe/keywords.rs             |  2 ++
 tests/unit/out/unsafe/kruskal.rs              |  2 ++
 tests/unit/out/unsafe/lambda_capture_pass.rs  |  2 ++
 tests/unit/out/unsafe/lambda_nested.rs        |  2 ++
 tests/unit/out/unsafe/libc_char_ptr_field.rs  |  2 ++
 .../out/unsafe/libc_struct_without_default.rs |  2 ++
 tests/unit/out/unsafe/linked_list.rs          |  2 ++
 .../out/unsafe/local_anon_struct_collision.rs |  2 ++
 .../unit/out/unsafe/loop_with_postfix_inc.rs  |  2 ++
 tests/unit/out/unsafe/lseek_ftruncate.rs      |  2 ++
 tests/unit/out/unsafe/lvalue_ref_goto.rs      |  2 ++
 tests/unit/out/unsafe/macros.rs               |  2 ++
 tests/unit/out/unsafe/main.rs                 |  6 ++++-
 tests/unit/out/unsafe/malloc_realloc_free.rs  |  2 ++
 tests/unit/out/unsafe/map-reallocation.rs     |  2 ++
 tests/unit/out/unsafe/map.rs                  |  2 ++
 tests/unit/out/unsafe/matmul.rs               |  2 ++
 tests/unit/out/unsafe/max.rs                  |  2 ++
 tests/unit/out/unsafe/memcpy_overlap.rs       |  2 ++
 tests/unit/out/unsafe/memcpy_struct_bytes.rs  |  2 ++
 tests/unit/out/unsafe/memcpy_struct_struct.rs |  2 ++
 tests/unit/out/unsafe/memset.rs               |  2 ++
 tests/unit/out/unsafe/min_max_ptr2ptr.rs      |  2 ++
 tests/unit/out/unsafe/move_assign.rs          |  2 ++
 tests/unit/out/unsafe/move_ctor.rs            |  2 ++
 tests/unit/out/unsafe/move_this.rs            |  2 ++
 tests/unit/out/unsafe/nested_block_scope.rs   |  2 ++
 tests/unit/out/unsafe/nested_structs.rs       |  2 ++
 tests/unit/out/unsafe/netdb.rs                |  2 ++
 tests/unit/out/unsafe/new.rs                  |  2 ++
 tests/unit/out/unsafe/new_alloc_array.rs      |  2 ++
 tests/unit/out/unsafe/new_array.rs            |  2 ++
 tests/unit/out/unsafe/new_array_var_size.rs   |  2 ++
 tests/unit/out/unsafe/new_bst.rs              |  2 ++
 tests/unit/out/unsafe/new_struct.rs           |  2 ++
 tests/unit/out/unsafe/no_direct_callee.rs     |  2 ++
 tests/unit/out/unsafe/null_compare.rs         |  2 ++
 tests/unit/out/unsafe/null_in_statics.rs      | 11 ++++++++
 tests/unit/out/unsafe/offsetof.rs             |  2 ++
 tests/unit/out/unsafe/opaque_forward_decl.rs  |  2 ++
 tests/unit/out/unsafe/opaque_record_copy.rs   |  2 ++
 tests/unit/out/unsafe/opaque_then_defined.rs  |  2 ++
 .../out/unsafe/operator_arithmetic_free.rs    |  2 ++
 .../out/unsafe/operator_arithmetic_member.rs  |  2 ++
 .../unit/out/unsafe/operator_bitwise_free.rs  |  2 ++
 .../out/unsafe/operator_bitwise_member.rs     |  2 ++
 .../unsafe/operator_comparison_defaulted.rs   |  2 ++
 .../out/unsafe/operator_comparison_free.rs    |  2 ++
 .../out/unsafe/operator_comparison_member.rs  |  2 ++
 .../out/unsafe/operator_comparison_mixed.rs   |  2 ++
 .../unsafe/operator_comparison_noncopyable.rs |  2 ++
 .../operator_compound_assignment_free.rs      |  2 ++
 .../operator_compound_assignment_member.rs    |  2 ++
 tests/unit/out/unsafe/operator_less_than.rs   |  2 ++
 .../unit/out/unsafe/operator_logical_free.rs  |  2 ++
 .../out/unsafe/operator_logical_member.rs     |  2 ++
 .../unsafe/operator_member_pointer_free.rs    |  2 ++
 .../unsafe/operator_member_pointer_member.rs  |  4 +++
 tests/unit/out/unsafe/operator_other_free.rs  |  2 ++
 .../unit/out/unsafe/operator_other_member.rs  |  2 ++
 tests/unit/out/unsafe/operator_overloads.rs   |  2 ++
 tests/unit/out/unsafe/operator_qualifiers.rs  |  2 ++
 tests/unit/out/unsafe/operator_synonyms.rs    |  2 ++
 tests/unit/out/unsafe/operator_three_way.rs   |  2 ++
 tests/unit/out/unsafe/operator_traits.rs      |  2 ++
 tests/unit/out/unsafe/overload_mangling.rs    |  2 ++
 tests/unit/out/unsafe/pair.rs                 |  2 ++
 tests/unit/out/unsafe/pipe_io.rs              |  2 ++
 tests/unit/out/unsafe/pod.rs                  |  2 ++
 tests/unit/out/unsafe/pointer_add_assign.rs   |  2 ++
 tests/unit/out/unsafe/pointer_arithmetic.rs   |  2 ++
 tests/unit/out/unsafe/pointer_array.rs        |  2 ++
 tests/unit/out/unsafe/pointer_call_offset.rs  |  2 ++
 tests/unit/out/unsafe/pointer_diff.rs         |  2 ++
 tests/unit/out/unsafe/pointer_eq.rs           |  2 ++
 tests/unit/out/unsafe/pointer_neq.rs          |  2 ++
 tests/unit/out/unsafe/pointer_offset.rs       |  2 ++
 tests/unit/out/unsafe/pointer_printf.rs       |  2 ++
 tests/unit/out/unsafe/pointer_to_boolean.rs   |  2 ++
 tests/unit/out/unsafe/pointer_usize_arith.rs  |  2 ++
 tests/unit/out/unsafe/pointers.rs             |  2 ++
 tests/unit/out/unsafe/poll.rs                 |  2 ++
 tests/unit/out/unsafe/polymorphism.rs         |  2 ++
 tests/unit/out/unsafe/printfs.rs              |  2 ++
 tests/unit/out/unsafe/prvalue-as-lvalue.rs    |  2 ++
 tests/unit/out/unsafe/ptr2ptr.rs              |  2 ++
 tests/unit/out/unsafe/ptr_cast_init.rs        |  2 ++
 .../out/unsafe/ptr_to_incomplete_struct.rs    |  2 ++
 tests/unit/out/unsafe/push_emplace_back.rs    |  2 ++
 tests/unit/out/unsafe/pwd.rs                  |  2 ++
 tests/unit/out/unsafe/qsort_bsearch.rs        |  2 ++
 tests/unit/out/unsafe/random.rs               |  2 ++
 tests/unit/out/unsafe/rebind.rs               |  2 ++
 .../unsafe/redundant_copy_in_conversion.rs    |  2 ++
 tests/unit/out/unsafe/ref_calls.rs            |  2 ++
 tests/unit/out/unsafe/reference_wrapper.rs    |  2 ++
 tests/unit/out/unsafe/references.rs           |  2 ++
 tests/unit/out/unsafe/references2.rs          |  2 ++
 tests/unit/out/unsafe/refs_as_args.rs         |  2 ++
 tests/unit/out/unsafe/reinterpret_cast.rs     |  2 ++
 .../out/unsafe/reinterpret_cast_aliased.rs    |  2 ++
 .../unsafe/reinterpret_cast_array_write.rs    |  2 ++
 .../unit/out/unsafe/reinterpret_cast_chain.rs |  2 ++
 .../out/unsafe/reinterpret_cast_double.rs     |  2 ++
 .../out/unsafe/reinterpret_cast_empty_vec.rs  |  2 ++
 .../unit/out/unsafe/reinterpret_cast_float.rs |  2 ++
 .../out/unsafe/reinterpret_cast_i16_u16.rs    |  2 ++
 .../out/unsafe/reinterpret_cast_identity.rs   |  2 ++
 .../out/unsafe/reinterpret_cast_iterate.rs    |  2 ++
 .../unsafe/reinterpret_cast_large_array.rs    |  2 ++
 tests/unit/out/unsafe/reinterpret_cast_new.rs |  2 ++
 .../out/unsafe/reinterpret_cast_new_array.rs  |  2 ++
 .../out/unsafe/reinterpret_cast_oob_read.rs   |  2 ++
 .../out/unsafe/reinterpret_cast_oob_write.rs  |  2 ++
 .../reinterpret_cast_partial_overlap.rs       |  2 ++
 .../out/unsafe/reinterpret_cast_roundtrip.rs  |  2 ++
 .../out/unsafe/reinterpret_cast_same_type.rs  |  2 ++
 .../out/unsafe/reinterpret_cast_signed.rs     |  2 ++
 .../out/unsafe/reinterpret_cast_string.rs     |  2 ++
 .../out/unsafe/reinterpret_cast_struct.rs     |  2 ++
 .../reinterpret_cast_struct_to_struct.rs      |  2 ++
 .../unsafe/reinterpret_cast_u32_from_u8.rs    |  2 ++
 .../out/unsafe/reinterpret_cast_undersize.rs  |  2 ++
 .../out/unsafe/reinterpret_cast_vec_write.rs  |  2 ++
 .../out/unsafe/reinterpret_cast_zero_init.rs  |  2 ++
 tests/unit/out/unsafe/reserved_keywords.rs    |  2 ++
 tests/unit/out/unsafe/ret_rvalue_ref.rs       |  2 ++
 tests/unit/out/unsafe/rule_of_five.rs         |  6 +++++
 tests/unit/out/unsafe/rule_of_three.rs        |  5 ++++
 tests/unit/out/unsafe/rvalue_ref_general.rs   |  2 ++
 tests/unit/out/unsafe/rvalue_ref_global.rs    |  4 +++
 tests/unit/out/unsafe/rvalue_ref_goto.rs      |  2 ++
 tests/unit/out/unsafe/rvalue_struct.rs        |  2 ++
 .../scalar_builtin_construct_destruct.rs      |  2 ++
 tests/unit/out/unsafe/select.rs               |  2 ++
 tests/unit/out/unsafe/simple_function.rs      |  2 ++
 tests/unit/out/unsafe/simple_index.rs         |  2 ++
 tests/unit/out/unsafe/size_t_ssize_t.rs       |  2 ++
 tests/unit/out/unsafe/snprintf.rs             |  2 ++
 tests/unit/out/unsafe/socket_listen.rs        |  2 ++
 tests/unit/out/unsafe/socket_open_close.rs    |  2 ++
 .../out/unsafe/socket_transparent_union.rs    |  2 ++
 .../unit/out/unsafe/socket_type_constants.rs  |  2 ++
 tests/unit/out/unsafe/sockopt.rs              |  2 ++
 tests/unit/out/unsafe/sort.rs                 |  2 ++
 .../out/unsafe/split_binop_aliased_borrows.rs |  2 ++
 tests/unit/out/unsafe/stable_sort.rs          |  2 ++
 .../unsafe/static_function_vars_same_name.rs  |  2 ++
 tests/unit/out/unsafe/static_local.rs         |  2 ++
 tests/unit/out/unsafe/static_shadow.rs        |  4 +++
 tests/unit/out/unsafe/static_var_in_class.rs  |  5 ++++
 tests/unit/out/unsafe/stdcopy.rs              |  2 ++
 tests/unit/out/unsafe/stdcopy_ostream.rs      |  2 ++
 tests/unit/out/unsafe/stdio.rs                |  2 ++
 tests/unit/out/unsafe/stdio_nofd.rs           |  2 ++
 tests/unit/out/unsafe/stdlib_h.rs             |  2 ++
 tests/unit/out/unsafe/stdmin_fpoint.rs        |  2 ++
 tests/unit/out/unsafe/stmt_expr.rs            |  2 ++
 tests/unit/out/unsafe/strdup.rs               |  2 ++
 tests/unit/out/unsafe/string.rs               |  2 ++
 tests/unit/out/unsafe/string2.rs              |  2 ++
 tests/unit/out/unsafe/string_escape.rs        |  2 ++
 tests/unit/out/unsafe/string_h.rs             |  2 ++
 .../unsafe/string_literal_interior_null.rs    |  4 +++
 .../out/unsafe/string_literal_ptr_init.rs     |  4 +++
 tests/unit/out/unsafe/string_literals.rs      |  2 ++
 tests/unit/out/unsafe/string_literals_c.rs    |  2 ++
 .../unit/out/unsafe/string_literals_concat.rs |  2 ++
 .../out/unsafe/string_literals_concat_c.rs    |  2 ++
 .../unit/out/unsafe/string_literals_return.rs |  2 ++
 .../out/unsafe/string_literals_return_c.rs    |  2 ++
 .../unit/out/unsafe/string_literals_sized.rs  |  2 ++
 .../out/unsafe/string_literals_sized_c.rs     |  2 ++
 tests/unit/out/unsafe/strlen.rs               |  2 ++
 tests/unit/out/unsafe/strlen_diff.rs          |  2 ++
 tests/unit/out/unsafe/strlen_rec.rs           |  2 ++
 tests/unit/out/unsafe/struct_ctor.rs          |  2 ++
 tests/unit/out/unsafe/struct_default_ctor.rs  |  2 ++
 tests/unit/out/unsafe/struct_ptr.rs           |  2 ++
 tests/unit/out/unsafe/swap.rs                 |  2 ++
 tests/unit/out/unsafe/swap_extended.rs        |  2 ++
 tests/unit/out/unsafe/switch_basic.rs         |  2 ++
 .../switch_borrow_in_condition_and_in_body.rs |  2 ++
 .../out/unsafe/switch_case_then_default.rs    |  2 ++
 .../switch_cases_and_default_stacked.rs       |  2 ++
 tests/unit/out/unsafe/switch_char.rs          |  2 ++
 tests/unit/out/unsafe/switch_complex_cond.rs  |  2 ++
 .../out/unsafe/switch_compound_case_body.rs   |  2 ++
 .../unsafe/switch_continue_inside_switch.rs   |  2 ++
 tests/unit/out/unsafe/switch_default_first.rs |  2 ++
 .../unit/out/unsafe/switch_default_middle.rs  |  2 ++
 .../out/unsafe/switch_default_then_case.rs    |  2 ++
 .../unsafe/switch_empty_case_with_break.rs    |  2 ++
 tests/unit/out/unsafe/switch_empty_switch.rs  |  2 ++
 tests/unit/out/unsafe/switch_enum.rs          |  2 ++
 .../out/unsafe/switch_fallthrough_chain.rs    |  2 ++
 .../out/unsafe/switch_fallthrough_default.rs  |  2 ++
 .../unsafe/switch_fallthrough_into_block.rs   |  2 ++
 .../unit/out/unsafe/switch_fallthrough_one.rs |  2 ++
 .../out/unsafe/switch_for_in_switch_break.rs  |  2 ++
 .../unsafe/switch_for_in_switch_continue.rs   |  2 ++
 .../out/unsafe/switch_for_switch_for_break.rs |  2 ++
 tests/unit/out/unsafe/switch_in_dowhile.rs    |  2 ++
 tests/unit/out/unsafe/switch_in_loop.rs       |  2 ++
 .../out/unsafe/switch_mixed_literal_cases.rs  |  2 ++
 .../out/unsafe/switch_mixed_return_break.rs   |  2 ++
 tests/unit/out/unsafe/switch_nested.rs        |  2 ++
 tests/unit/out/unsafe/switch_no_default.rs    |  2 ++
 tests/unit/out/unsafe/switch_on_assignment.rs |  2 ++
 tests/unit/out/unsafe/switch_on_call.rs       |  2 ++
 tests/unit/out/unsafe/switch_only_default.rs  |  2 ++
 tests/unit/out/unsafe/switch_stacked.rs       |  2 ++
 tests/unit/out/unsafe/switch_stacked_block.rs |  2 ++
 .../switch_stacked_with_inner_fallthrough.rs  |  2 ++
 .../unsafe/switch_while_in_switch_break.rs    |  2 ++
 tests/unit/out/unsafe/sys_stat.rs             |  2 ++
 tests/unit/out/unsafe/sys_time.rs             |  2 ++
 .../out/unsafe/tag_vs_identifier_collision.rs |  2 ++
 tests/unit/out/unsafe/template_pack.rs        |  2 ++
 tests/unit/out/unsafe/templates.rs            |  2 ++
 tests/unit/out/unsafe/termios.rs              |  2 ++
 tests/unit/out/unsafe/this.rs                 |  2 ++
 tests/unit/out/unsafe/typedef-anon-struct.rs  |  2 ++
 tests/unit/out/unsafe/types.rs                |  2 ++
 tests/unit/out/unsafe/unary.rs                |  2 ++
 .../out/unsafe/unary_expr_or_type_trait.rs    |  2 ++
 tests/unit/out/unsafe/unconst.rs              |  2 ++
 .../unit/out/unsafe/union_addrof_external.rs  |  2 ++
 tests/unit/out/unsafe/union_basic.rs          |  2 ++
 tests/unit/out/unsafe/union_cross_arm_cast.rs |  2 ++
 .../unit/out/unsafe/union_field_alignment.rs  |  2 ++
 .../out/unsafe/union_flex_array_member.rs     |  2 ++
 tests/unit/out/unsafe/union_memset_memcpy.rs  |  2 ++
 tests/unit/out/unsafe/union_nested.rs         |  2 ++
 .../out/unsafe/union_pointer_pun_address.rs   |  2 ++
 .../unsafe/union_pointer_pun_writethrough.rs  |  2 ++
 .../unit/out/unsafe/union_struct_dual_use.rs  |  2 ++
 .../unit/out/unsafe/union_tagged_many_arms.rs |  2 ++
 tests/unit/out/unsafe/union_tagged_simple.rs  |  2 ++
 .../out/unsafe/union_tagged_struct_arms.rs    |  2 ++
 .../out/unsafe/union_void_ptr_sized_deref.rs  |  2 ++
 tests/unit/out/unsafe/unique_ptr.rs           |  2 ++
 .../unit/out/unsafe/unique_ptr_const_deref.rs |  2 ++
 tests/unit/out/unsafe/unique_ptr_deref_ops.rs |  2 ++
 tests/unit/out/unsafe/unique_ptr_nested.rs    |  2 ++
 tests/unit/out/unsafe/unique_ptr_small.rs     |  2 ++
 tests/unit/out/unsafe/unique_ptr_struct.rs    |  2 ++
 tests/unit/out/unsafe/unistd.rs               |  2 ++
 tests/unit/out/unsafe/unsigned.rs             |  2 ++
 .../out/unsafe/user_defined_same_as_libc.rs   |  2 ++
 tests/unit/out/unsafe/va_arg_chain.rs         |  2 ++
 tests/unit/out/unsafe/va_arg_concat.rs        |  2 ++
 tests/unit/out/unsafe/va_arg_conditional.rs   |  2 ++
 tests/unit/out/unsafe/va_arg_copy.rs          |  2 ++
 tests/unit/out/unsafe/va_arg_fn_ptr.rs        |  2 ++
 tests/unit/out/unsafe/va_arg_forward.rs       |  2 ++
 tests/unit/out/unsafe/va_arg_mixed_int_ptr.rs |  2 ++
 tests/unit/out/unsafe/va_arg_mixed_types.rs   |  2 ++
 .../out/unsafe/va_arg_non_primitive_ptrs.rs   |  2 ++
 tests/unit/out/unsafe/va_arg_null_int_ptr.rs  |  2 ++
 tests/unit/out/unsafe/va_arg_printf.rs        |  2 ++
 tests/unit/out/unsafe/va_arg_promotion.rs     |  2 ++
 tests/unit/out/unsafe/va_arg_snprintf.rs      |  2 ++
 tests/unit/out/unsafe/va_arg_struct_ctx.rs    |  2 ++
 tests/unit/out/unsafe/va_arg_two_passes.rs    |  2 ++
 tests/unit/out/unsafe/va_arg_void_ptr.rs      |  2 ++
 tests/unit/out/unsafe/vector.rs               |  2 ++
 tests/unit/out/unsafe/vector2.rs              |  2 ++
 tests/unit/out/unsafe/vector3.rs              |  2 ++
 tests/unit/out/unsafe/vector_addr_of_back.rs  |  2 ++
 .../unit/out/unsafe/vector_iter_range_ctor.rs |  2 ++
 .../unit/out/unsafe/vector_with_allocator.rs  |  2 ++
 tests/unit/out/unsafe/void_cast.rs            |  4 +++
 .../unsafe/void_ptr_implicit_conversion.rs    |  2 ++
 tests/unit/out/unsafe/void_return.rs          |  2 ++
 tests/unit/out/unsafe/void_round_trip.rs      |  2 ++
 tests/unit/out/unsafe/z_bit_cast.rs           |  2 ++
 927 files changed, 2103 insertions(+), 6 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 76c20fb64..8fae52702 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/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_;
@@ -74,6 +75,23 @@ std::string Converter::EmitMethodsOnPtr() {
   return out;
 }
 
+std::string Converter::ForceGlobalInit(const clang::VarDecl *decl) {
+  return std::format("std::cell::LazyCell::force(&*&raw const {});",
+                     GetNamedDeclAsString(decl));
+}
+
+std::string Converter::EmitGlobalInits(Model model) {
+  std::string 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";
+  return out;
+}
+
 std::string Converter::EmitOpaqueRecords() {
   std::string out;
   record_decls_.ForEachUndefined([&](const std::string &name) {
@@ -512,6 +530,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()) {
@@ -4180,14 +4199,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));
   }
 }
 
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 9f601de97..7b1b1b1e5 100644
--- a/cpp2rust/converter/converter.h
+++ b/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"
@@ -52,6 +53,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
   virtual void EmitFilePreamble();
 
   static std::string EmitOpaqueRecords();
+  static std::string EmitGlobalInits(Model model);
 
   static std::string EmitMethodsOnPtr();
 
@@ -99,6 +101,7 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   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);
 
@@ -1016,6 +1019,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
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 4c10e3750..b83cfd034 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -2410,6 +2410,12 @@ void ConverterRefCount::ConvertPointerSubscript(
   }
 }
 
+std::string ConverterRefCount::ForceGlobalInit(const clang::VarDecl *decl) {
+  const auto *clone =
+      decl->getType()->isReferenceType() ? "Ptr::clone" : "Value::clone";
+  return std::format("let _ = {}.with({});", GetNamedDeclAsString(decl), clone);
+}
+
 void ConverterRefCount::ConvertFunctionMain(
     const clang::FunctionDecl *decl,
     const std::string_view main_function_name) {
@@ -2423,12 +2429,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));
   }
 }
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index 28b95447f..4f651495f 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -80,6 +80,7 @@ class ConverterRefCount final : public Converter {
 
   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;
 
diff --git a/cpp2rust/cpp2rust_lib.cpp b/cpp2rust/cpp2rust_lib.cpp
index 5c15a4536..6e73c22d7 100644
--- a/cpp2rust/cpp2rust_lib.cpp
+++ b/cpp2rust/cpp2rust_lib.cpp
@@ -32,6 +32,7 @@ std::string TranspileSrc(std::string_view cc_code, Model model,
       filename.ends_with(".c") ? CLANG_C_COMPILER : CLANG_CXX_COMPILER);
   rs_code += Converter::EmitOpaqueRecords();
   rs_code += Converter::EmitMethodsOnPtr();
+  rs_code += Converter::EmitGlobalInits(model);
   return rs_code;
 }
 
@@ -73,6 +74,7 @@ std::string TranspileDir(std::string_view build_dir, Model model,
   Tool.run(&factory);
   rs_code += Converter::EmitOpaqueRecords();
   rs_code += Converter::EmitMethodsOnPtr();
+  rs_code += Converter::EmitGlobalInits(model);
   return rs_code;
 }
 } // namespace cpp2rust
diff --git a/tests/multi-file/cross_tu_anon_enum_collision/out/refcount/cross_tu_anon_enum_collision.rs b/tests/multi-file/cross_tu_anon_enum_collision/out/refcount/cross_tu_anon_enum_collision.rs
index 7cf386448..72d39e851 100644
--- a/tests/multi-file/cross_tu_anon_enum_collision/out/refcount/cross_tu_anon_enum_collision.rs
+++ b/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() {}
diff --git a/tests/multi-file/cross_tu_anon_enum_collision/out/unsafe/cross_tu_anon_enum_collision.rs b/tests/multi-file/cross_tu_anon_enum_collision/out/unsafe/cross_tu_anon_enum_collision.rs
index 85d80f283..6620daee1 100644
--- a/tests/multi-file/cross_tu_anon_enum_collision/out/unsafe/cross_tu_anon_enum_collision.rs
+++ b/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() {}
diff --git a/tests/multi-file/cross_tu_tag_collision/out/refcount/cross_tu_tag_collision.rs b/tests/multi-file/cross_tu_tag_collision/out/refcount/cross_tu_tag_collision.rs
index e5499920f..ec058a7bf 100644
--- a/tests/multi-file/cross_tu_tag_collision/out/refcount/cross_tu_tag_collision.rs
+++ b/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() {}
diff --git a/tests/multi-file/cross_tu_tag_collision/out/unsafe/cross_tu_tag_collision.rs b/tests/multi-file/cross_tu_tag_collision/out/unsafe/cross_tu_tag_collision.rs
index 3da000215..fb1bdc361 100644
--- a/tests/multi-file/cross_tu_tag_collision/out/unsafe/cross_tu_tag_collision.rs
+++ b/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() {}
diff --git a/tests/multi-file/extern_functions/out/refcount/extern_functions.rs b/tests/multi-file/extern_functions/out/refcount/extern_functions.rs
index e9170cd2c..0434c0e6c 100644
--- a/tests/multi-file/extern_functions/out/refcount/extern_functions.rs
+++ b/tests/multi-file/extern_functions/out/refcount/extern_functions.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -29,3 +30,4 @@ pub fn helper_0(x: i32) -> i32 {
     &({ unrelated3_3() });
     return ((*x.borrow()) + 1);
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/multi-file/extern_functions/out/unsafe/extern_functions.rs b/tests/multi-file/extern_functions/out/unsafe/extern_functions.rs
index 2c594f5ab..27ceb5dae 100644
--- a/tests/multi-file/extern_functions/out/unsafe/extern_functions.rs
+++ b/tests/multi-file/extern_functions/out/unsafe/extern_functions.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ pub unsafe fn helper_0(mut x: i32) -> i32 {
     &(unsafe { unrelated3_3() });
     return ((x) + (1));
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/multi-file/header_function/out/refcount/header_function.rs b/tests/multi-file/header_function/out/refcount/header_function.rs
index e9170cd2c..0434c0e6c 100644
--- a/tests/multi-file/header_function/out/refcount/header_function.rs
+++ b/tests/multi-file/header_function/out/refcount/header_function.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -29,3 +30,4 @@ pub fn helper_0(x: i32) -> i32 {
     &({ unrelated3_3() });
     return ((*x.borrow()) + 1);
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/multi-file/header_function/out/unsafe/header_function.rs b/tests/multi-file/header_function/out/unsafe/header_function.rs
index 2c594f5ab..27ceb5dae 100644
--- a/tests/multi-file/header_function/out/unsafe/header_function.rs
+++ b/tests/multi-file/header_function/out/unsafe/header_function.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ pub unsafe fn helper_0(mut x: i32) -> i32 {
     &(unsafe { unrelated3_3() });
     return ((x) + (1));
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs b/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs
index 694e35774..39f2fd4f3 100644
--- a/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs
+++ b/tests/multi-file/opaque_forward_decl/out/refcount/opaque_forward_decl.rs
@@ -35,6 +35,7 @@ impl ByteRepr for container {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -53,3 +54,4 @@ pub fn touch_0(c: Ptr<container>) {
 }
 #[derive(Clone, Copy, Default, ByteRepr)]
 pub struct opaque;
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/multi-file/opaque_forward_decl/out/unsafe/opaque_forward_decl.rs b/tests/multi-file/opaque_forward_decl/out/unsafe/opaque_forward_decl.rs
index cb79b4503..419c29841 100644
--- a/tests/multi-file/opaque_forward_decl/out/unsafe/opaque_forward_decl.rs
+++ b/tests/multi-file/opaque_forward_decl/out/unsafe/opaque_forward_decl.rs
@@ -14,6 +14,7 @@ pub struct container {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -32,3 +33,4 @@ pub unsafe fn touch_0(mut c: *mut container) {
 }
 #[derive(Clone, Copy, Default, ByteRepr)]
 pub struct opaque;
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs b/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs
index d87da909a..1a5a06d8f 100644
--- a/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs
+++ b/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs
@@ -19,6 +19,7 @@ pub fn a_bar_3() -> i32 {
     return (*same_name_same_type_1.with(Value::clone).borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,9 @@ pub fn b_foo_4() -> f32 {
 pub fn b_bar_5() -> i32 {
     return (*same_name_same_type_7.with(Value::clone).borrow());
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = same_name_different_type_0.with(Value::clone);
+    let _ = same_name_same_type_1.with(Value::clone);
+    let _ = same_name_different_type_6.with(Value::clone);
+    let _ = same_name_same_type_7.with(Value::clone);
+}
diff --git a/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs b/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs
index 88cd3770a..c8ab07740 100644
--- a/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs
+++ b/tests/multi-file/static_name_collision/out/unsafe/static_name_collision.rs
@@ -18,6 +18,7 @@ pub unsafe fn a_bar_3() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,9 @@ pub unsafe fn b_foo_4() -> f32 {
 pub unsafe fn b_bar_5() -> i32 {
     return (*std::cell::LazyCell::force_mut(&mut *&raw mut same_name_same_type_7));
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const same_name_different_type_0);
+    std::cell::LazyCell::force(&*&raw const same_name_same_type_1);
+    std::cell::LazyCell::force(&*&raw const same_name_different_type_6);
+    std::cell::LazyCell::force(&*&raw const same_name_same_type_7);
+}
diff --git a/tests/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs b/tests/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs
index 285f4984a..4bbe92ed3 100644
--- a/tests/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs
+++ b/tests/multi-file/template_method_late_instantiation/out/refcount/template_method_late_instantiation.rs
@@ -33,6 +33,7 @@ impl ByteRepr for S_int_ {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -58,3 +59,4 @@ impl S_int_Impl for Ptr<S_int_> {
         return (*(*(*self).upgrade().deref()).x.borrow());
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/multi-file/template_method_late_instantiation/out/unsafe/template_method_late_instantiation.rs b/tests/multi-file/template_method_late_instantiation/out/unsafe/template_method_late_instantiation.rs
index 880214e0b..1addc0275 100644
--- a/tests/multi-file/template_method_late_instantiation/out/unsafe/template_method_late_instantiation.rs
+++ b/tests/multi-file/template_method_late_instantiation/out/unsafe/template_method_late_instantiation.rs
@@ -18,6 +18,7 @@ impl S_int_ {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ impl S_int_ {
 pub unsafe fn f_0(mut p: *mut S_int_) -> i32 {
     return (unsafe { S_int_::get(&mut (*p)) });
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ctor_ref_member.rs b/tests/ub/out/refcount/ctor_ref_member.rs
index f99be5a9f..485688a0f 100644
--- a/tests/ub/out/refcount/ctor_ref_member.rs
+++ b/tests/ub/out/refcount/ctor_ref_member.rs
@@ -28,6 +28,7 @@ impl Clone for S {
 }
 impl ByteRepr for S {}
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -38,3 +39,4 @@ fn main_0() -> i32 {
     assert!((((*s.borrow()).r.read()) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs b/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs
index 34db3f751..98370becb 100644
--- a/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs
+++ b/tests/ub/out/refcount/dangling-prvalue-as-lvalue.rs
@@ -10,6 +10,7 @@ pub fn foo_0(a: Ptr<i32>) -> Ptr<i32> {
     return (a).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     (*v.borrow_mut()).clear();
     return (b.read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/enum_out_of_range_cast.rs b/tests/ub/out/refcount/enum_out_of_range_cast.rs
index 3ca857102..88ea45f51 100644
--- a/tests/ub/out/refcount/enum_out_of_range_cast.rs
+++ b/tests/ub/out/refcount/enum_out_of_range_cast.rs
@@ -11,6 +11,7 @@ pub const Color_RED: Color = 0;
 pub const Color_GREEN: Color = 1;
 pub const Color_BLUE: Color = 2;
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
         1
     };
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/enum_out_of_range_increment.rs b/tests/ub/out/refcount/enum_out_of_range_increment.rs
index 0b88267bb..5f22ad11d 100644
--- a/tests/ub/out/refcount/enum_out_of_range_increment.rs
+++ b/tests/ub/out/refcount/enum_out_of_range_increment.rs
@@ -11,6 +11,7 @@ pub const color_RED: color = 0;
 pub const color_GREEN: color = 1;
 pub const color_BLUE: color = 2;
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
         1
     };
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/fd_close_invalid.rs b/tests/ub/out/refcount/fd_close_invalid.rs
index ed2b4ca2f..003b7be9e 100644
--- a/tests/ub/out/refcount/fd_close_invalid.rs
+++ b/tests/ub/out/refcount/fd_close_invalid.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
         1
     };
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/fd_double_close.rs b/tests/ub/out/refcount/fd_double_close.rs
index 183e96de5..1434c283f 100644
--- a/tests/ub/out/refcount/fd_double_close.rs
+++ b/tests/ub/out/refcount/fd_double_close.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -36,3 +37,4 @@ fn main_0() -> i32 {
         1
     };
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/fd_use_after_close.rs b/tests/ub/out/refcount/fd_use_after_close.rs
index 93b7f621e..a1160c367 100644
--- a/tests/ub/out/refcount/fd_use_after_close.rs
+++ b/tests/ub/out/refcount/fd_use_after_close.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -55,3 +56,4 @@ fn main_0() -> i32 {
         1
     };
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/file_use_after_fclose.rs b/tests/ub/out/refcount/file_use_after_fclose.rs
index 73c4f73e4..22f2ed1d6 100644
--- a/tests/ub/out/refcount/file_use_after_fclose.rs
+++ b/tests/ub/out/refcount/file_use_after_fclose.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -39,3 +40,4 @@ fn main_0() -> i32 {
         0
     };
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/max.rs b/tests/ub/out/refcount/max.rs
index 1f35f4ed1..298f5581e 100644
--- a/tests/ub/out/refcount/max.rs
+++ b/tests/ub/out/refcount/max.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
         _lhs == (b.read())
     }) as i32);
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ret_ref_to_local.rs b/tests/ub/out/refcount/ret_ref_to_local.rs
index 22b8643f2..82eb93e73 100644
--- a/tests/ub/out/refcount/ret_ref_to_local.rs
+++ b/tests/ub/out/refcount/ret_ref_to_local.rs
@@ -11,9 +11,11 @@ pub fn foo_0() -> Ptr<i32> {
     return __tmp_0.as_pointer();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     let bar: Value<i32> = Rc::new(RefCell::new((({ foo_0() }).read())));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub1.rs b/tests/ub/out/refcount/ub1.rs
index 40b608909..6972c93b5 100644
--- a/tests/ub/out/refcount/ub1.rs
+++ b/tests/ub/out/refcount/ub1.rs
@@ -12,9 +12,11 @@ pub fn dangling_0() -> Ptr<i32> {
     return (*p.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     let x: Ptr<i32> = ({ dangling_0() });
     return (x.read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub10.rs b/tests/ub/out/refcount/ub10.rs
index feabbc90c..9d007a731 100644
--- a/tests/ub/out/refcount/ub10.rs
+++ b/tests/ub/out/refcount/ub10.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     (*ptr.borrow()).delete_array();
     return (*out.borrow());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub11.rs b/tests/ub/out/refcount/ub11.rs
index a2ed43869..0ed3b67b6 100644
--- a/tests/ub/out/refcount/ub11.rs
+++ b/tests/ub/out/refcount/ub11.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     (*element.borrow()).delete();
     return (*out.borrow());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub12.rs b/tests/ub/out/refcount/ub12.rs
index a2e39dca8..9e551c50e 100644
--- a/tests/ub/out/refcount/ub12.rs
+++ b/tests/ub/out/refcount/ub12.rs
@@ -11,6 +11,7 @@ pub fn escape_0(ptr: Ptr<i32>) {
     (*ptr.borrow()).delete();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     (*alloc.borrow()).delete();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub13.rs b/tests/ub/out/refcount/ub13.rs
index da837124b..e403aadea 100644
--- a/tests/ub/out/refcount/ub13.rs
+++ b/tests/ub/out/refcount/ub13.rs
@@ -11,6 +11,7 @@ pub fn escape_0(p: Ptr<i32>) {
     (*p.borrow()).delete();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     ({ escape_0((*p1.borrow()).clone()) });
     return ((*p1.borrow()).read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub14.rs b/tests/ub/out/refcount/ub14.rs
index 719d21eea..cdf0bc343 100644
--- a/tests/ub/out/refcount/ub14.rs
+++ b/tests/ub/out/refcount/ub14.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     (*arr1.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub15.rs b/tests/ub/out/refcount/ub15.rs
index 39007f65c..03b81ecd3 100644
--- a/tests/ub/out/refcount/ub15.rs
+++ b/tests/ub/out/refcount/ub15.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     (*arr.borrow()).delete_array();
     return (*out.borrow());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub16.rs b/tests/ub/out/refcount/ub16.rs
index fce22fa4a..d70fba02e 100644
--- a/tests/ub/out/refcount/ub16.rs
+++ b/tests/ub/out/refcount/ub16.rs
@@ -11,6 +11,7 @@ pub fn foo_0(a: Ptr<i32>) -> Ptr<i32> {
     return ((*a.borrow()).offset((5) as isize));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -27,3 +28,4 @@ fn main_0() -> i32 {
     (*p1.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub17.rs b/tests/ub/out/refcount/ub17.rs
index 36af30256..f23955ac7 100644
--- a/tests/ub/out/refcount/ub17.rs
+++ b/tests/ub/out/refcount/ub17.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     (*p.borrow()).delete();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub18.rs b/tests/ub/out/refcount/ub18.rs
index 1a593dc7d..1666020f6 100644
--- a/tests/ub/out/refcount/ub18.rs
+++ b/tests/ub/out/refcount/ub18.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     (*p.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub19.rs b/tests/ub/out/refcount/ub19.rs
index 9daa3e7ca..46027acf2 100644
--- a/tests/ub/out/refcount/ub19.rs
+++ b/tests/ub/out/refcount/ub19.rs
@@ -11,6 +11,7 @@ pub fn foo_0(array: Ptr<i32>) {
     (*array.borrow()).delete_array();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     ({ foo_0((*x.borrow()).clone()) });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub2.rs b/tests/ub/out/refcount/ub2.rs
index 2959cf226..5a8f8d564 100644
--- a/tests/ub/out/refcount/ub2.rs
+++ b/tests/ub/out/refcount/ub2.rs
@@ -11,9 +11,11 @@ pub fn null_0() -> Ptr<i32> {
     return (*p.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     let x: Value<Ptr<i32>> = Rc::new(RefCell::new(({ null_0() })));
     return ((*x.borrow()).read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub20.rs b/tests/ub/out/refcount/ub20.rs
index f8c7c5eea..01a79f603 100644
--- a/tests/ub/out/refcount/ub20.rs
+++ b/tests/ub/out/refcount/ub20.rs
@@ -11,6 +11,7 @@ pub fn foo_0(single: Ptr<i32>) {
     (*single.borrow()).delete();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
     ({ foo_0((*x.borrow()).clone()) });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub21.rs b/tests/ub/out/refcount/ub21.rs
index 8925e4171..7feb56e0b 100644
--- a/tests/ub/out/refcount/ub21.rs
+++ b/tests/ub/out/refcount/ub21.rs
@@ -15,6 +15,7 @@ pub fn strlen_0(s: Ptr<u8>) -> usize {
     return (*count.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -25,3 +26,4 @@ fn main_0() -> i32 {
     ])));
     return (({ strlen_0((s.as_pointer() as Ptr<u8>)) }) as i32);
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub3.rs b/tests/ub/out/refcount/ub3.rs
index 6587e28cb..4e4d8d81c 100644
--- a/tests/ub/out/refcount/ub3.rs
+++ b/tests/ub/out/refcount/ub3.rs
@@ -12,9 +12,11 @@ pub fn dangling_0() -> Ptr<i32> {
     return (*p.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     let x: Value<Ptr<i32>> = Rc::new(RefCell::new(({ dangling_0() })));
     return ((*x.borrow()).read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub4.rs b/tests/ub/out/refcount/ub4.rs
index 1b0d7b226..b738b89fc 100644
--- a/tests/ub/out/refcount/ub4.rs
+++ b/tests/ub/out/refcount/ub4.rs
@@ -17,6 +17,7 @@ pub fn smaller_0(x1: Ptr<i32>, x2: Ptr<i32>) -> Ptr<i32> {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     }
     return ((*out.borrow()).read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub5.rs b/tests/ub/out/refcount/ub5.rs
index deef6d0cb..26eab3772 100644
--- a/tests/ub/out/refcount/ub5.rs
+++ b/tests/ub/out/refcount/ub5.rs
@@ -11,6 +11,7 @@ pub fn null_0(p: Ptr<Ptr<i32>>) {
     (*p.borrow()).write(Ptr::<i32>::null());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     let r: Ptr<i32> = (*p.borrow()).clone();
     return (r.read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub6.rs b/tests/ub/out/refcount/ub6.rs
index e7628b27f..ad4b8c8fd 100644
--- a/tests/ub/out/refcount/ub6.rs
+++ b/tests/ub/out/refcount/ub6.rs
@@ -60,6 +60,7 @@ pub fn any_2(arr: Ptr<Option<Value<Box<[Ptr<i32>]>>>>, n1: Ptr<i32>) -> bool {
     return (*out.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -73,3 +74,4 @@ fn main_0() -> i32 {
     ({ fill_1(arr.as_pointer(), n.as_pointer()) });
     return (({ any_2(arr.as_pointer(), n.as_pointer()) }) as i32);
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub7.rs b/tests/ub/out/refcount/ub7.rs
index 3a5cd4d26..fb6035d4d 100644
--- a/tests/ub/out/refcount/ub7.rs
+++ b/tests/ub/out/refcount/ub7.rs
@@ -15,6 +15,7 @@ pub fn strlen_0(s: Ptr<u8>) -> usize {
     return ((((*s.borrow()).clone() - (*begin.borrow()).clone()) as i64) as usize);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     ])));
     return (({ strlen_0(((s.as_pointer() as Ptr<u8>).offset(0))) }) as i32);
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub8.rs b/tests/ub/out/refcount/ub8.rs
index e68690c18..939cb67fc 100644
--- a/tests/ub/out/refcount/ub8.rs
+++ b/tests/ub/out/refcount/ub8.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     let p: Value<Ptr<i32>> = Rc::new(RefCell::new((x.as_pointer())));
     return ((*p.borrow_mut()).prefix_inc().read());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/refcount/ub9.rs b/tests/ub/out/refcount/ub9.rs
index a286b527c..711b7321a 100644
--- a/tests/ub/out/refcount/ub9.rs
+++ b/tests/ub/out/refcount/ub9.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     (*arr.borrow()).delete_array();
     return (*out.borrow());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ctor_ref_member.rs b/tests/ub/out/unsafe/ctor_ref_member.rs
index 8e2dc8471..6370e24cf 100644
--- a/tests/ub/out/unsafe/ctor_ref_member.rs
+++ b/tests/ub/out/unsafe/ctor_ref_member.rs
@@ -19,6 +19,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*s.r) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
index dbe39a02c..418b283ec 100644
--- a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
+++ b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(a: *const i32) -> *const i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     v.clear();
     return (*b);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/enum_out_of_range_cast.rs b/tests/ub/out/unsafe/enum_out_of_range_cast.rs
index 981690e48..634c80eae 100644
--- a/tests/ub/out/unsafe/enum_out_of_range_cast.rs
+++ b/tests/ub/out/unsafe/enum_out_of_range_cast.rs
@@ -12,6 +12,7 @@ pub const Color_GREEN: Color = 1;
 pub const Color_BLUE: Color = 2;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
         1
     };
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/enum_out_of_range_increment.rs b/tests/ub/out/unsafe/enum_out_of_range_increment.rs
index 993fec1b0..19493d356 100644
--- a/tests/ub/out/unsafe/enum_out_of_range_increment.rs
+++ b/tests/ub/out/unsafe/enum_out_of_range_increment.rs
@@ -12,6 +12,7 @@ pub const color_GREEN: color = 1;
 pub const color_BLUE: color = 2;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
         1
     };
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/fd_close_invalid.rs b/tests/ub/out/unsafe/fd_close_invalid.rs
index b5cfb4c8e..9198925d5 100644
--- a/tests/ub/out/unsafe/fd_close_invalid.rs
+++ b/tests/ub/out/unsafe/fd_close_invalid.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
         1
     };
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/fd_double_close.rs b/tests/ub/out/unsafe/fd_double_close.rs
index d26a2c4eb..d9076b6ef 100644
--- a/tests/ub/out/unsafe/fd_double_close.rs
+++ b/tests/ub/out/unsafe/fd_double_close.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -25,3 +26,4 @@ unsafe fn main_0() -> i32 {
         1
     };
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/fd_use_after_close.rs b/tests/ub/out/unsafe/fd_use_after_close.rs
index 45de7482e..e1e9e65ac 100644
--- a/tests/ub/out/unsafe/fd_use_after_close.rs
+++ b/tests/ub/out/unsafe/fd_use_after_close.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
         1
     };
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/file_use_after_fclose.rs b/tests/ub/out/unsafe/file_use_after_fclose.rs
index c576dd9d8..17a784c0e 100644
--- a/tests/ub/out/unsafe/file_use_after_fclose.rs
+++ b/tests/ub/out/unsafe/file_use_after_fclose.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
         0
     };
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/max.rs b/tests/ub/out/unsafe/max.rs
index d63c284bc..cd757bcc3 100644
--- a/tests/ub/out/unsafe/max.rs
+++ b/tests/ub/out/unsafe/max.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -32,3 +33,4 @@ unsafe fn main_0() -> i32 {
     };
     return (((*a) == (*b)) as i32);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ret_ref_to_local.rs b/tests/ub/out/unsafe/ret_ref_to_local.rs
index 6b6f85b3b..264241698 100644
--- a/tests/ub/out/unsafe/ret_ref_to_local.rs
+++ b/tests/ub/out/unsafe/ret_ref_to_local.rs
@@ -12,6 +12,7 @@ pub unsafe fn foo_0() -> *const i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     let mut bar: i32 = (*(unsafe { foo_0() }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub1.rs b/tests/ub/out/unsafe/ub1.rs
index 5ad662e9b..3b70074e1 100644
--- a/tests/ub/out/unsafe/ub1.rs
+++ b/tests/ub/out/unsafe/ub1.rs
@@ -13,6 +13,7 @@ pub unsafe fn dangling_0() -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     let x: *mut i32 = (unsafe { dangling_0() });
     return (*x);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub10.rs b/tests/ub/out/unsafe/ub10.rs
index a6e029df2..35ba41fc6 100644
--- a/tests/ub/out/unsafe/ub10.rs
+++ b/tests/ub/out/unsafe/ub10.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     )));
     return out;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub11.rs b/tests/ub/out/unsafe/ub11.rs
index 10310eaa8..a24855447 100644
--- a/tests/ub/out/unsafe/ub11.rs
+++ b/tests/ub/out/unsafe/ub11.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     ::std::mem::drop(Box::from_raw(element));
     return out;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub12.rs b/tests/ub/out/unsafe/ub12.rs
index 305521853..6abb788d3 100644
--- a/tests/ub/out/unsafe/ub12.rs
+++ b/tests/ub/out/unsafe/ub12.rs
@@ -11,6 +11,7 @@ pub unsafe fn escape_0(mut ptr: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     ::std::mem::drop(Box::from_raw(alloc));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub13.rs b/tests/ub/out/unsafe/ub13.rs
index 2d9016a0b..cfd615347 100644
--- a/tests/ub/out/unsafe/ub13.rs
+++ b/tests/ub/out/unsafe/ub13.rs
@@ -11,6 +11,7 @@ pub unsafe fn escape_0(mut p: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { escape_0(p1) });
     return (*p1);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub14.rs b/tests/ub/out/unsafe/ub14.rs
index a56a50007..a8c494055 100644
--- a/tests/ub/out/unsafe/ub14.rs
+++ b/tests/ub/out/unsafe/ub14.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub15.rs b/tests/ub/out/unsafe/ub15.rs
index b35b14eea..99c605c8e 100644
--- a/tests/ub/out/unsafe/ub15.rs
+++ b/tests/ub/out/unsafe/ub15.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     )));
     return out;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub16.rs b/tests/ub/out/unsafe/ub16.rs
index f5485e25c..91bff8772 100644
--- a/tests/ub/out/unsafe/ub16.rs
+++ b/tests/ub/out/unsafe/ub16.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(mut a: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub17.rs b/tests/ub/out/unsafe/ub17.rs
index 420ae0254..b54012736 100644
--- a/tests/ub/out/unsafe/ub17.rs
+++ b/tests/ub/out/unsafe/ub17.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     ::std::mem::drop(Box::from_raw(p));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub18.rs b/tests/ub/out/unsafe/ub18.rs
index 072a63efc..3b4d67645 100644
--- a/tests/ub/out/unsafe/ub18.rs
+++ b/tests/ub/out/unsafe/ub18.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub19.rs b/tests/ub/out/unsafe/ub19.rs
index e922299d3..15cef6943 100644
--- a/tests/ub/out/unsafe/ub19.rs
+++ b/tests/ub/out/unsafe/ub19.rs
@@ -14,6 +14,7 @@ pub unsafe fn foo_0(mut array: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { foo_0(x) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub2.rs b/tests/ub/out/unsafe/ub2.rs
index c31e89255..5429bb89e 100644
--- a/tests/ub/out/unsafe/ub2.rs
+++ b/tests/ub/out/unsafe/ub2.rs
@@ -12,6 +12,7 @@ pub unsafe fn null_0() -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     let mut x: *mut i32 = (unsafe { null_0() });
     return (*x);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub20.rs b/tests/ub/out/unsafe/ub20.rs
index 43b8f7036..635585f6a 100644
--- a/tests/ub/out/unsafe/ub20.rs
+++ b/tests/ub/out/unsafe/ub20.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(mut single: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { foo_0(x) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub21.rs b/tests/ub/out/unsafe/ub21.rs
index ca595328c..68b446d82 100644
--- a/tests/ub/out/unsafe/ub21.rs
+++ b/tests/ub/out/unsafe/ub21.rs
@@ -15,6 +15,7 @@ pub unsafe fn strlen_0(mut s: *const libc::c_char) -> usize {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     ];
     return ((unsafe { strlen_0(s.as_ptr()) }) as i32);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub3.rs b/tests/ub/out/unsafe/ub3.rs
index 872c14a6f..49c5feed2 100644
--- a/tests/ub/out/unsafe/ub3.rs
+++ b/tests/ub/out/unsafe/ub3.rs
@@ -13,6 +13,7 @@ pub unsafe fn dangling_0() -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     let mut x: *mut i32 = (unsafe { dangling_0() });
     return (*x);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub4.rs b/tests/ub/out/unsafe/ub4.rs
index df61ee198..c17e909d4 100644
--- a/tests/ub/out/unsafe/ub4.rs
+++ b/tests/ub/out/unsafe/ub4.rs
@@ -11,6 +11,7 @@ pub unsafe fn smaller_0(x1: *mut i32, x2: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     }
     return (*out);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub5.rs b/tests/ub/out/unsafe/ub5.rs
index c148459a8..7e09242cf 100644
--- a/tests/ub/out/unsafe/ub5.rs
+++ b/tests/ub/out/unsafe/ub5.rs
@@ -11,6 +11,7 @@ pub unsafe fn null_0(mut p: *mut *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     let r: *mut i32 = &mut (*p) as *mut i32;
     return (*r);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub6.rs b/tests/ub/out/unsafe/ub6.rs
index e1c323513..e48d1ad19 100644
--- a/tests/ub/out/unsafe/ub6.rs
+++ b/tests/ub/out/unsafe/ub6.rs
@@ -36,6 +36,7 @@ pub unsafe fn any_2(arr: *mut Option<Box<[*mut i32]>>, n1: *mut i32) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -50,3 +51,4 @@ unsafe fn main_0() -> i32 {
     return ((unsafe { any_2(&mut arr as *mut Option<Box<[*mut i32]>>, &mut n as *mut i32) })
         as i32);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub7.rs b/tests/ub/out/unsafe/ub7.rs
index fbe355d94..ee28ce748 100644
--- a/tests/ub/out/unsafe/ub7.rs
+++ b/tests/ub/out/unsafe/ub7.rs
@@ -16,6 +16,7 @@ pub unsafe fn strlen_0(mut s: *const libc::c_char) -> usize {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     ];
     return ((unsafe { strlen_0((&s[(0) as usize] as *const libc::c_char)) }) as i32);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub8.rs b/tests/ub/out/unsafe/ub8.rs
index 8aee78701..7c533cda1 100644
--- a/tests/ub/out/unsafe/ub8.rs
+++ b/tests/ub/out/unsafe/ub8.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     let mut p: *mut i32 = (&mut x as *mut i32);
     return (*p.prefix_inc());
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub9.rs b/tests/ub/out/unsafe/ub9.rs
index c774466fc..2d697ad35 100644
--- a/tests/ub/out/unsafe/ub9.rs
+++ b/tests/ub/out/unsafe/ub9.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     )));
     return out;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/01_local.rs b/tests/unit/out/refcount/01_local.rs
index 41a5f59b6..c97816bd8 100644
--- a/tests/unit/out/refcount/01_local.rs
+++ b/tests/unit/out/refcount/01_local.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     assert!(((*a.borrow()) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/02_address_taken.rs b/tests/unit/out/refcount/02_address_taken.rs
index 866b26395..937d046e6 100644
--- a/tests/unit/out/refcount/02_address_taken.rs
+++ b/tests/unit/out/refcount/02_address_taken.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -23,3 +24,4 @@ fn main_0() -> i32 {
     assert!(((*b.borrow()) == 4));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/03_local_array.rs b/tests/unit/out/refcount/03_local_array.rs
index 0575c9a45..14607044c 100644
--- a/tests/unit/out/refcount/03_local_array.rs
+++ b/tests/unit/out/refcount/03_local_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     assert!((((*arr1.borrow())[(0) as usize] + (*arr1.borrow())[(1) as usize]) == 7));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/04_address_taken_array.rs b/tests/unit/out/refcount/04_address_taken_array.rs
index 8f88f5567..0e2d78edf 100644
--- a/tests/unit/out/refcount/04_address_taken_array.rs
+++ b/tests/unit/out/refcount/04_address_taken_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -21,3 +22,4 @@ fn main_0() -> i32 {
     assert!((((*arr2.borrow())[(0) as usize] + (*arr2.borrow())[(1) as usize]) == 12));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/05_new.rs b/tests/unit/out/refcount/05_new.rs
index 48360cc83..189f3cbaa 100644
--- a/tests/unit/out/refcount/05_new.rs
+++ b/tests/unit/out/refcount/05_new.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     (*d.borrow()).delete();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/06_new_array.rs b/tests/unit/out/refcount/06_new_array.rs
index b85fcee26..76802443a 100644
--- a/tests/unit/out/refcount/06_new_array.rs
+++ b/tests/unit/out/refcount/06_new_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     (*e.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/07_unique.rs b/tests/unit/out/refcount/07_unique.rs
index 9fab5506e..e270ab598 100644
--- a/tests/unit/out/refcount/07_unique.rs
+++ b/tests/unit/out/refcount/07_unique.rs
@@ -12,6 +12,7 @@ pub fn fn_0(u: Option<Value<i32>>) -> Option<Value<i32>> {
     return (*u.borrow_mut()).take();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     assert!(((*(*f.borrow()).as_ref().unwrap().borrow()) == 10));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/08_unique_array.rs b/tests/unit/out/refcount/08_unique_array.rs
index d10b2e58b..e6c3e9cf0 100644
--- a/tests/unit/out/refcount/08_unique_array.rs
+++ b/tests/unit/out/refcount/08_unique_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -25,3 +26,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/09_references.rs b/tests/unit/out/refcount/09_references.rs
index ce5e6f829..73fd3e701 100644
--- a/tests/unit/out/refcount/09_references.rs
+++ b/tests/unit/out/refcount/09_references.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/10_struct.rs b/tests/unit/out/refcount/10_struct.rs
index 2ac2c7a37..99bdb8733 100644
--- a/tests/unit/out/refcount/10_struct.rs
+++ b/tests/unit/out/refcount/10_struct.rs
@@ -67,6 +67,7 @@ impl ByteRepr for Graph {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -109,3 +110,4 @@ impl GraphImpl for Ptr<Graph> {
             .write(__rhs);
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/11_move.rs b/tests/unit/out/refcount/11_move.rs
index 3cd5d9fbf..8bbc6c7ce 100644
--- a/tests/unit/out/refcount/11_move.rs
+++ b/tests/unit/out/refcount/11_move.rs
@@ -12,6 +12,7 @@ pub fn change_0(n: Ptr<Option<Value<i32>>>) {
     assert!(((*m.borrow()).as_pointer()).is_null());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     assert!(((*(*n.borrow()).as_ref().unwrap().borrow()) == 20));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/12_test.rs b/tests/unit/out/refcount/12_test.rs
index de352b0c6..2ee9e0008 100644
--- a/tests/unit/out/refcount/12_test.rs
+++ b/tests/unit/out/refcount/12_test.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -21,3 +22,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/13_testing.rs b/tests/unit/out/refcount/13_testing.rs
index 747840cfe..1a84c0a5b 100644
--- a/tests/unit/out/refcount/13_testing.rs
+++ b/tests/unit/out/refcount/13_testing.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     ((*p2.borrow()).read()).write(3);
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/14_testing2.rs b/tests/unit/out/refcount/14_testing2.rs
index decfe1f1a..e46ef1b33 100644
--- a/tests/unit/out/refcount/14_testing2.rs
+++ b/tests/unit/out/refcount/14_testing2.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     assert!((((*ptr.borrow()).read()) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/__builtin_constant_p.rs b/tests/unit/out/refcount/__builtin_constant_p.rs
index 8602ed261..ddb7efd5d 100644
--- a/tests/unit/out/refcount/__builtin_constant_p.rs
+++ b/tests/unit/out/refcount/__builtin_constant_p.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     assert!(((1 + 2) == 3));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/addr_of_global.rs b/tests/unit/out/refcount/addr_of_global.rs
index 2c3aceb0e..f028004d9 100644
--- a/tests/unit/out/refcount/addr_of_global.rs
+++ b/tests/unit/out/refcount/addr_of_global.rs
@@ -85,6 +85,7 @@ thread_local!(
     }));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -136,3 +137,10 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = alpha_0.with(Value::clone);
+    let _ = beta_1.with(Value::clone);
+    let _ = shared_2.with(Value::clone);
+    let _ = items_3.with(Value::clone);
+    let _ = obj_4.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/alloc_array.rs b/tests/unit/out/refcount/alloc_array.rs
index 6fbf5bf04..002400014 100644
--- a/tests/unit/out/refcount/alloc_array.rs
+++ b/tests/unit/out/refcount/alloc_array.rs
@@ -34,6 +34,7 @@ pub fn Consume_1(arr: Option<Value<Box<[i32]>>>, N: i32) -> i32 {
     return (*sum.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -47,3 +48,4 @@ fn main_0() -> i32 {
     assert!((({ Consume_1((*arr.borrow_mut()).take(), (*N.borrow()),) }) == 10));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/anonymous-struct.rs b/tests/unit/out/refcount/anonymous-struct.rs
index 64d82f14e..eb23315bc 100644
--- a/tests/unit/out/refcount/anonymous-struct.rs
+++ b/tests/unit/out/refcount/anonymous-struct.rs
@@ -255,6 +255,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -368,3 +369,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/anonymous-struct_c.rs b/tests/unit/out/refcount/anonymous-struct_c.rs
index 065fd2cc2..251213da9 100644
--- a/tests/unit/out/refcount/anonymous-struct_c.rs
+++ b/tests/unit/out/refcount/anonymous-struct_c.rs
@@ -239,6 +239,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -335,3 +336,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/anonymous_enum.rs b/tests/unit/out/refcount/anonymous_enum.rs
index 2e954d73e..5b4432208 100644
--- a/tests/unit/out/refcount/anonymous_enum.rs
+++ b/tests/unit/out/refcount/anonymous_enum.rs
@@ -75,6 +75,7 @@ impl ByteRepr for WithAnonField {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -95,3 +96,4 @@ fn main_0() -> i32 {
     assert!((((*(*w.borrow()).field.borrow()) as i32) == (anon_2_FIELD_B as i32)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/anonymous_enum_c.rs b/tests/unit/out/refcount/anonymous_enum_c.rs
index 82240be28..6b4f7b792 100644
--- a/tests/unit/out/refcount/anonymous_enum_c.rs
+++ b/tests/unit/out/refcount/anonymous_enum_c.rs
@@ -71,6 +71,7 @@ impl ByteRepr for WithAnonField {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -97,3 +98,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/array.rs b/tests/unit/out/refcount/array.rs
index 04848deb2..0c1566825 100644
--- a/tests/unit/out/refcount/array.rs
+++ b/tests/unit/out/refcount/array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     assert!(((*fatorial.borrow()) == 120));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/array_2d_default.rs b/tests/unit/out/refcount/array_2d_default.rs
index 2e77999a2..ddf0d4e75 100644
--- a/tests/unit/out/refcount/array_2d_default.rs
+++ b/tests/unit/out/refcount/array_2d_default.rs
@@ -16,6 +16,7 @@ pub fn fill_row_0(row: Ptr<u8>, c: u8) {
         .write((('\0' as i32) as u8));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -64,3 +65,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/array_const_init.rs b/tests/unit/out/refcount/array_const_init.rs
index b0e467de1..760e2ccc2 100644
--- a/tests/unit/out/refcount/array_const_init.rs
+++ b/tests/unit/out/refcount/array_const_init.rs
@@ -59,6 +59,7 @@ thread_local!(
     }));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -83,3 +84,6 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = s_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/array_of_noncopy_struct.rs b/tests/unit/out/refcount/array_of_noncopy_struct.rs
index 93f131759..32ab1026e 100644
--- a/tests/unit/out/refcount/array_of_noncopy_struct.rs
+++ b/tests/unit/out/refcount/array_of_noncopy_struct.rs
@@ -37,6 +37,7 @@ impl ByteRepr for NonCopy {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -59,3 +60,4 @@ fn main_0() -> i32 {
     assert!(((*(*arr.borrow())[(2) as usize].data.borrow()).len() == 0_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/array_reference.rs b/tests/unit/out/refcount/array_reference.rs
index 1ddf2c9d8..fd73fcccb 100644
--- a/tests/unit/out/refcount/array_reference.rs
+++ b/tests/unit/out/refcount/array_reference.rs
@@ -160,6 +160,7 @@ pub fn total_len_9(names: Ptr<Box<[Ptr<u8>]>>) -> i32 {
     }));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -211,3 +212,4 @@ fn main_0() -> i32 {
     assert!((({ total_len_9((names.as_pointer() as Ptr<Box<[Ptr::<u8>]>>),) }) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/assert.rs b/tests/unit/out/refcount/assert.rs
index 60923cb90..6ec5357aa 100644
--- a/tests/unit/out/refcount/assert.rs
+++ b/tests/unit/out/refcount/assert.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     assert!((1 == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/assign_as_value.rs b/tests/unit/out/refcount/assign_as_value.rs
index bf16523ba..ebc5443df 100644
--- a/tests/unit/out/refcount/assign_as_value.rs
+++ b/tests/unit/out/refcount/assign_as_value.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -46,3 +47,4 @@ fn main_0() -> i32 {
     assert!((((((*out.borrow()) as i32) == ('x' as i32)) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/auto.rs b/tests/unit/out/refcount/auto.rs
index 45d2ce428..643e3d84d 100644
--- a/tests/unit/out/refcount/auto.rs
+++ b/tests/unit/out/refcount/auto.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 3));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bool_condition_enum.rs b/tests/unit/out/refcount/bool_condition_enum.rs
index 4d32a20e9..b4fa7e4cd 100644
--- a/tests/unit/out/refcount/bool_condition_enum.rs
+++ b/tests/unit/out/refcount/bool_condition_enum.rs
@@ -11,6 +11,7 @@ pub const Code_CODE_OK: Code = 0;
 pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     assert!(!(*b4.borrow()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bool_condition_enum_c.rs b/tests/unit/out/refcount/bool_condition_enum_c.rs
index c36390048..c812ef505 100644
--- a/tests/unit/out/refcount/bool_condition_enum_c.rs
+++ b/tests/unit/out/refcount/bool_condition_enum_c.rs
@@ -11,6 +11,7 @@ pub const Code_CODE_OK: Code = 0;
 pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     assert!(((!(*b4.borrow()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bool_condition_int.rs b/tests/unit/out/refcount/bool_condition_int.rs
index ad21faed0..d7183ff85 100644
--- a/tests/unit/out/refcount/bool_condition_int.rs
+++ b/tests/unit/out/refcount/bool_condition_int.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -69,3 +70,4 @@ fn main_0() -> i32 {
     assert!((*b1.borrow()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bool_condition_int_c.rs b/tests/unit/out/refcount/bool_condition_int_c.rs
index 7578ebc09..78ce5b02f 100644
--- a/tests/unit/out/refcount/bool_condition_int_c.rs
+++ b/tests/unit/out/refcount/bool_condition_int_c.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -69,3 +70,4 @@ fn main_0() -> i32 {
     assert!((*b1.borrow()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bool_condition_logical.rs b/tests/unit/out/refcount/bool_condition_logical.rs
index 25ebf4e35..0e1e3ed66 100644
--- a/tests/unit/out/refcount/bool_condition_logical.rs
+++ b/tests/unit/out/refcount/bool_condition_logical.rs
@@ -25,6 +25,7 @@ pub fn returns_zero_3() -> i32 {
     return 0;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -131,3 +132,6 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = side_effect_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/bool_condition_logical_c.rs b/tests/unit/out/refcount/bool_condition_logical_c.rs
index 210c7b3e9..14bbe4383 100644
--- a/tests/unit/out/refcount/bool_condition_logical_c.rs
+++ b/tests/unit/out/refcount/bool_condition_logical_c.rs
@@ -25,6 +25,7 @@ pub fn returns_zero_3() -> i32 {
     return 0;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -175,3 +176,6 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = side_effect_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/bool_condition_ptr.rs b/tests/unit/out/refcount/bool_condition_ptr.rs
index a6b9afa02..c0357e1fc 100644
--- a/tests/unit/out/refcount/bool_condition_ptr.rs
+++ b/tests/unit/out/refcount/bool_condition_ptr.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -46,3 +47,4 @@ fn main_0() -> i32 {
     assert!(!(*b3.borrow()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bool_condition_ptr_c.rs b/tests/unit/out/refcount/bool_condition_ptr_c.rs
index 8966ba6b8..fddc76dd3 100644
--- a/tests/unit/out/refcount/bool_condition_ptr_c.rs
+++ b/tests/unit/out/refcount/bool_condition_ptr_c.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -46,3 +47,4 @@ fn main_0() -> i32 {
     assert!(((!(*b3.borrow()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bool_printing.rs b/tests/unit/out/refcount/bool_printing.rs
index 757575d42..5f67a4c78 100644
--- a/tests/unit/out/refcount/bool_printing.rs
+++ b/tests/unit/out/refcount/bool_printing.rs
@@ -13,6 +13,7 @@ pub fn bar_1() -> bool {
     return true;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     write!(libcc2rs::cout(), "{:}\n", (({ bar_1() }) as u8),);
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/borrow_mut_opt.rs b/tests/unit/out/refcount/borrow_mut_opt.rs
index 4125f1cab..b55965df2 100644
--- a/tests/unit/out/refcount/borrow_mut_opt.rs
+++ b/tests/unit/out/refcount/borrow_mut_opt.rs
@@ -104,6 +104,7 @@ pub fn convert_with_rhs_1() {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -111,3 +112,4 @@ fn main_0() -> i32 {
     ({ convert_with_rhs_1() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bounded_struct_ptr.rs b/tests/unit/out/refcount/bounded_struct_ptr.rs
index 738c6dcc7..f7a35b3e0 100644
--- a/tests/unit/out/refcount/bounded_struct_ptr.rs
+++ b/tests/unit/out/refcount/bounded_struct_ptr.rs
@@ -37,6 +37,7 @@ impl ByteRepr for Foo {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -63,3 +64,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/break.rs b/tests/unit/out/refcount/break.rs
index 9cdc02d80..beed4f73b 100644
--- a/tests/unit/out/refcount/break.rs
+++ b/tests/unit/out/refcount/break.rs
@@ -32,9 +32,11 @@ pub fn for_test_0(n: i32) -> i32 {
     return (*x.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ for_test_0(200,) }) == 400));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/bst.rs b/tests/unit/out/refcount/bst.rs
index 97e18ef6d..8a36763d0 100644
--- a/tests/unit/out/refcount/bst.rs
+++ b/tests/unit/out/refcount/bst.rs
@@ -105,6 +105,7 @@ pub fn insert_1(node: Ptr<node_t>, new_node: Ptr<node_t>) -> Ptr<node_t> {
     return (*node.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -172,3 +173,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/builtin.rs b/tests/unit/out/refcount/builtin.rs
index e4d1af150..c7ae24e12 100644
--- a/tests/unit/out/refcount/builtin.rs
+++ b/tests/unit/out/refcount/builtin.rs
@@ -70,6 +70,7 @@ pub fn test_mul_overflow_long_long_9() {
     });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -85,3 +86,4 @@ fn main_0() -> i32 {
     ({ test_mul_overflow_long_long_9() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/builtin_types_compatible.rs b/tests/unit/out/refcount/builtin_types_compatible.rs
index 5f59d13d0..066208d30 100644
--- a/tests/unit/out/refcount/builtin_types_compatible.rs
+++ b/tests/unit/out/refcount/builtin_types_compatible.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -23,3 +24,4 @@ fn main_0() -> i32 {
     assert!((((0 == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/byte.rs b/tests/unit/out/refcount/byte.rs
index c7b6fbfac..bbe77a951 100644
--- a/tests/unit/out/refcount/byte.rs
+++ b/tests/unit/out/refcount/byte.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     assert!(((*b1.borrow()) == 4));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/c_struct.rs b/tests/unit/out/refcount/c_struct.rs
index fd1e1b3ee..846635164 100644
--- a/tests/unit/out/refcount/c_struct.rs
+++ b/tests/unit/out/refcount/c_struct.rs
@@ -155,6 +155,7 @@ impl ByteRepr for Container {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -215,3 +216,4 @@ fn main_0() -> i32 {
     assert!((((((*(*c2.borrow()).color.borrow()) as u32) == 2_u32) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/cast.rs b/tests/unit/out/refcount/cast.rs
index af20aa816..b877e1cdf 100644
--- a/tests/unit/out/refcount/cast.rs
+++ b/tests/unit/out/refcount/cast.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     assert!(((*size.borrow()) == 1_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/cast_array_to_pointer_decay.rs b/tests/unit/out/refcount/cast_array_to_pointer_decay.rs
index 69265f366..47da1ecca 100644
--- a/tests/unit/out/refcount/cast_array_to_pointer_decay.rs
+++ b/tests/unit/out/refcount/cast_array_to_pointer_decay.rs
@@ -19,6 +19,7 @@ pub fn strlen_1(s: Ptr<u8>) -> i32 {
     return (*c.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -36,3 +37,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/char_printing.rs b/tests/unit/out/refcount/char_printing.rs
index 94842479a..a3a2ed9aa 100644
--- a/tests/unit/out/refcount/char_printing.rs
+++ b/tests/unit/out/refcount/char_printing.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -55,3 +56,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/char_printing_cerr.rs b/tests/unit/out/refcount/char_printing_cerr.rs
index 7453502a8..66a1cab73 100644
--- a/tests/unit/out/refcount/char_printing_cerr.rs
+++ b/tests/unit/out/refcount/char_printing_cerr.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -55,3 +56,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/class.rs b/tests/unit/out/refcount/class.rs
index e3e63d83d..fdc497eb7 100644
--- a/tests/unit/out/refcount/class.rs
+++ b/tests/unit/out/refcount/class.rs
@@ -83,6 +83,7 @@ pub fn RandomRoute_0(route: Ptr<Route>) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -169,3 +170,4 @@ impl RouteImpl for Ptr<Route> {
         return (*old_cost.borrow());
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/class_template_lazy_member.rs b/tests/unit/out/refcount/class_template_lazy_member.rs
index 6b7c2190c..a1e920a69 100644
--- a/tests/unit/out/refcount/class_template_lazy_member.rs
+++ b/tests/unit/out/refcount/class_template_lazy_member.rs
@@ -85,6 +85,7 @@ impl ByteRepr for Box_Point_ {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -117,3 +118,4 @@ impl Box_int_Impl for Ptr<Box_int_> {
             + (*(*(*self).upgrade().deref()).val.borrow()));
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/class_templates.rs b/tests/unit/out/refcount/class_templates.rs
index 269962fb3..a30862fb9 100644
--- a/tests/unit/out/refcount/class_templates.rs
+++ b/tests/unit/out/refcount/class_templates.rs
@@ -85,6 +85,7 @@ impl ByteRepr for MyContainer_float_ {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -211,3 +212,4 @@ impl MyContainer_int_Impl for Ptr<MyContainer_int_> {
         };
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/clone_vs_move.rs b/tests/unit/out/refcount/clone_vs_move.rs
index 2b8c7c403..2b09d0009 100644
--- a/tests/unit/out/refcount/clone_vs_move.rs
+++ b/tests/unit/out/refcount/clone_vs_move.rs
@@ -68,6 +68,7 @@ impl Default for Foo {
 }
 impl ByteRepr for Foo {}
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -507,3 +508,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/comma_operator.rs b/tests/unit/out/refcount/comma_operator.rs
index 5d643a5ce..9657c2055 100644
--- a/tests/unit/out/refcount/comma_operator.rs
+++ b/tests/unit/out/refcount/comma_operator.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -43,3 +44,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/complex_function.rs b/tests/unit/out/refcount/complex_function.rs
index 245903fcd..d6e7609ff 100644
--- a/tests/unit/out/refcount/complex_function.rs
+++ b/tests/unit/out/refcount/complex_function.rs
@@ -110,6 +110,7 @@ impl ByteRepr for X4 {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -423,3 +424,4 @@ impl X4Impl for Ptr<X4> {
         return (*(*self).upgrade().deref()).v.as_pointer();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/compound_assign_paren.rs b/tests/unit/out/refcount/compound_assign_paren.rs
index ac6acd029..9f0974167 100644
--- a/tests/unit/out/refcount/compound_assign_paren.rs
+++ b/tests/unit/out/refcount/compound_assign_paren.rs
@@ -33,6 +33,7 @@ impl ByteRepr for Item {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -86,3 +87,4 @@ fn main_0() -> i32 {
     assert!((((*(*(*ptr.borrow()).upgrade().deref()).flags.borrow()) as i32) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/compound_assign_ref.rs b/tests/unit/out/refcount/compound_assign_ref.rs
index 6b94fc47a..9cac2dd37 100644
--- a/tests/unit/out/refcount/compound_assign_ref.rs
+++ b/tests/unit/out/refcount/compound_assign_ref.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!((((v.as_pointer() as Ptr<i32>).read()) == 15));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/constexpr_function.rs b/tests/unit/out/refcount/constexpr_function.rs
index d3b6c46b1..c57304321 100644
--- a/tests/unit/out/refcount/constexpr_function.rs
+++ b/tests/unit/out/refcount/constexpr_function.rs
@@ -52,6 +52,7 @@ impl ByteRepr for P {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -77,3 +78,4 @@ impl PImpl for Ptr<P> {
         return (*(*(*self).upgrade().deref()).v.borrow());
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/constructor.rs b/tests/unit/out/refcount/constructor.rs
index aa1d6dc92..158b73715 100644
--- a/tests/unit/out/refcount/constructor.rs
+++ b/tests/unit/out/refcount/constructor.rs
@@ -48,6 +48,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -77,3 +78,6 @@ impl SImpl for Ptr<S> {
         (*total_0.with(Value::clone).borrow_mut()) += ({ SImpl::const_method(self) });
     }
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = total_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/continue.rs b/tests/unit/out/refcount/continue.rs
index 64af5fe42..530f25312 100644
--- a/tests/unit/out/refcount/continue.rs
+++ b/tests/unit/out/refcount/continue.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -59,3 +60,4 @@ fn main_0() -> i32 {
     assert!(((*out.borrow()) == 81));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/copy_assign.rs b/tests/unit/out/refcount/copy_assign.rs
index 1eec39b5a..2e377db18 100644
--- a/tests/unit/out/refcount/copy_assign.rs
+++ b/tests/unit/out/refcount/copy_assign.rs
@@ -183,6 +183,7 @@ impl ByteRepr for Holder {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -303,3 +304,6 @@ impl RefQualifiedImpl for Ptr<RefQualified> {
         return (*self).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = assigns_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/copy_ctor.rs b/tests/unit/out/refcount/copy_ctor.rs
index bab142e20..5c04cdaa4 100644
--- a/tests/unit/out/refcount/copy_ctor.rs
+++ b/tests/unit/out/refcount/copy_ctor.rs
@@ -157,6 +157,7 @@ pub fn make_2(v: i32) -> Counted {
     return Counted::Counted_pconstCounted({ c.as_pointer() });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -230,3 +231,6 @@ fn main_0() -> i32 {
     assert!(((*(*n2.borrow()).mark.borrow()) == 10));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = copies_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/cout_alias.rs b/tests/unit/out/refcount/cout_alias.rs
index 74497fc46..6bf3b4bf4 100644
--- a/tests/unit/out/refcount/cout_alias.rs
+++ b/tests/unit/out/refcount/cout_alias.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -25,3 +26,4 @@ fn main_0() -> i32 {
     write!(os2, "hello\n",);
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/cstring.rs b/tests/unit/out/refcount/cstring.rs
index 82bb41958..840229226 100644
--- a/tests/unit/out/refcount/cstring.rs
+++ b/tests/unit/out/refcount/cstring.rs
@@ -914,6 +914,7 @@ pub fn test_strcasecmp_15() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -935,3 +936,4 @@ fn main_0() -> i32 {
     ({ test_strcasecmp_15() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/default.rs b/tests/unit/out/refcount/default.rs
index 0ebec44fe..471009cd3 100644
--- a/tests/unit/out/refcount/default.rs
+++ b/tests/unit/out/refcount/default.rs
@@ -68,6 +68,7 @@ impl ByteRepr for Pointers {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -79,3 +80,4 @@ fn main_0() -> i32 {
     (*default_pointers.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/default_function_arguments.rs b/tests/unit/out/refcount/default_function_arguments.rs
index d7b475afc..6316882c0 100644
--- a/tests/unit/out/refcount/default_function_arguments.rs
+++ b/tests/unit/out/refcount/default_function_arguments.rs
@@ -61,6 +61,7 @@ impl ByteRepr for Bar {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -88,3 +89,4 @@ fn main_0() -> i32 {
     assert!(((*(*arr.borrow())[(2) as usize].v.borrow()) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/default_in_statics.rs b/tests/unit/out/refcount/default_in_statics.rs
index 0302d002b..fb9bd6abb 100644
--- a/tests/unit/out/refcount/default_in_statics.rs
+++ b/tests/unit/out/refcount/default_in_statics.rs
@@ -223,6 +223,7 @@ pub fn check_local_static_5() {
     assert!((*local_p_8.with(Value::clone).borrow()).is_null());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -285,3 +286,10 @@ fn main_0() -> i32 {
     ({ check_local_static_5() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = static_fn_0.with(Value::clone);
+    let _ = static_outer_1.with(Value::clone);
+    let _ = static_inner_array_2.with(Value::clone);
+    let _ = static_foo_3.with(Value::clone);
+    let _ = static_foo_array_4.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/destructor.rs b/tests/unit/out/refcount/destructor.rs
index 4e10438d7..34a53f3b7 100644
--- a/tests/unit/out/refcount/destructor.rs
+++ b/tests/unit/out/refcount/destructor.rs
@@ -321,6 +321,7 @@ impl ByteRepr for Ordered {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -514,3 +515,8 @@ impl Templated_int_Impl for Ptr<Templated_int_> {
         };
     }
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = global_0.with(Value::clone);
+    let _ = order_1.with(Value::clone);
+    let _ = order_count_2.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/do_while_continue.rs b/tests/unit/out/refcount/do_while_continue.rs
index 13b7d264b..571c35df3 100644
--- a/tests/unit/out/refcount/do_while_continue.rs
+++ b/tests/unit/out/refcount/do_while_continue.rs
@@ -41,6 +41,7 @@ pub fn nested_1() -> i32 {
     return (*runs.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -48,3 +49,4 @@ fn main_0() -> i32 {
     assert!((((({ nested_1() }) == 6) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/doubly_linked_list.rs b/tests/unit/out/refcount/doubly_linked_list.rs
index 306ce35f9..bb37a9259 100644
--- a/tests/unit/out/refcount/doubly_linked_list.rs
+++ b/tests/unit/out/refcount/doubly_linked_list.rs
@@ -120,6 +120,7 @@ pub fn Tail_4(head: Ptr<Node>) -> Ptr<Node> {
     return (*curr.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -445,3 +446,4 @@ impl NodeImpl for Ptr<Node> {
         (*(*(*self).upgrade().deref()).prev.borrow_mut()) = (*p.borrow()).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/dowhile.rs b/tests/unit/out/refcount/dowhile.rs
index 5e9b79b75..a2ceee856 100644
--- a/tests/unit/out/refcount/dowhile.rs
+++ b/tests/unit/out/refcount/dowhile.rs
@@ -23,9 +23,11 @@ pub fn dowhile_0(x: i32) -> i32 {
     return (*x.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ dowhile_0(0,) }) == 202));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/empty_array_init.rs b/tests/unit/out/refcount/empty_array_init.rs
index 888a14f83..047804591 100644
--- a/tests/unit/out/refcount/empty_array_init.rs
+++ b/tests/unit/out/refcount/empty_array_init.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     ));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/empty_main.rs b/tests/unit/out/refcount/empty_main.rs
index be7ceea31..0bc61fbb2 100644
--- a/tests/unit/out/refcount/empty_main.rs
+++ b/tests/unit/out/refcount/empty_main.rs
@@ -20,6 +20,7 @@ pub fn main() {
             .collect(),
     ));
     (*argv.borrow_mut()).push(Ptr::null());
+    __cpp2rust_init_globals();
     ::std::process::exit(main_0(::std::env::args().len() as i32, argv.as_pointer()));
 }
 fn main_0(_a0: i32, _a1: Ptr<Ptr<u8>>) -> i32 {
@@ -27,3 +28,4 @@ fn main_0(_a0: i32, _a1: Ptr<Ptr<u8>>) -> i32 {
     let _a1: Value<Ptr<Ptr<u8>>> = Rc::new(RefCell::new(_a1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/enum_comparisson_in_globals.rs b/tests/unit/out/refcount/enum_comparisson_in_globals.rs
index c5cb7a392..fef923ce5 100644
--- a/tests/unit/out/refcount/enum_comparisson_in_globals.rs
+++ b/tests/unit/out/refcount/enum_comparisson_in_globals.rs
@@ -14,9 +14,13 @@ thread_local!(
         Rc::new(RefCell::new((((E_A as i32) != (E_B as i32)) as i32)));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!(((*global_0.with(Value::clone).borrow()) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = global_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/enum_default_in_static.rs b/tests/unit/out/refcount/enum_default_in_static.rs
index 6c8ee7a36..6f1f4868c 100644
--- a/tests/unit/out/refcount/enum_default_in_static.rs
+++ b/tests/unit/out/refcount/enum_default_in_static.rs
@@ -42,6 +42,7 @@ thread_local!(
     pub static config_0: Value<Config> = <Value<Config>>::default();
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -53,3 +54,6 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = config_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/enum_increment.rs b/tests/unit/out/refcount/enum_increment.rs
index 7df0bc1a6..600646112 100644
--- a/tests/unit/out/refcount/enum_increment.rs
+++ b/tests/unit/out/refcount/enum_increment.rs
@@ -12,6 +12,7 @@ pub const color_GREEN: color = 1;
 pub const color_BLUE: color = 2;
 pub const color_COLOR_LAST: color = 3;
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -37,3 +38,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/enum_int_interop.rs b/tests/unit/out/refcount/enum_int_interop.rs
index 7bf3e6320..fc785b20f 100644
--- a/tests/unit/out/refcount/enum_int_interop.rs
+++ b/tests/unit/out/refcount/enum_int_interop.rs
@@ -114,6 +114,7 @@ pub fn make_color_6(n: i32) -> Color {
     return ((*n.borrow()) as Color);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -234,3 +235,9 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = global_color_0.with(Value::clone);
+    let _ = global_opt_1.with(Value::clone);
+    let _ = global_tag_2.with(Value::clone);
+    let _ = entries_3.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/enum_int_interop_c.rs b/tests/unit/out/refcount/enum_int_interop_c.rs
index 4daf19359..2066c0292 100644
--- a/tests/unit/out/refcount/enum_int_interop_c.rs
+++ b/tests/unit/out/refcount/enum_int_interop_c.rs
@@ -112,6 +112,7 @@ pub fn make_color_6(n: i32) -> Color {
     return ((*n.borrow()) as Color);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -297,3 +298,9 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = global_color_0.with(Value::clone);
+    let _ = global_opt_1.with(Value::clone);
+    let _ = global_tag_2.with(Value::clone);
+    let _ = entries_3.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/enum_with_duplicated_values.rs b/tests/unit/out/refcount/enum_with_duplicated_values.rs
index 0c1b5c5de..f272a8e6a 100644
--- a/tests/unit/out/refcount/enum_with_duplicated_values.rs
+++ b/tests/unit/out/refcount/enum_with_duplicated_values.rs
@@ -12,6 +12,7 @@ pub const E_B: E = 4;
 pub const E_C: E = 2;
 pub const E_D: E = 4;
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -21,3 +22,4 @@ fn main_0() -> i32 {
     assert!(((E_D as i32) == (1 << 2)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/errno.rs b/tests/unit/out/refcount/errno.rs
index 2cf9c8bcb..f7300dcc0 100644
--- a/tests/unit/out/refcount/errno.rs
+++ b/tests/unit/out/refcount/errno.rs
@@ -38,6 +38,7 @@ pub fn test_errno_from_fseek_2() {
     libcc2rs::cpp2rust_errno().write(0);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -46,3 +47,4 @@ fn main_0() -> i32 {
     ({ test_errno_from_fseek_2() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/expr_as_bool_c.rs b/tests/unit/out/refcount/expr_as_bool_c.rs
index 62d58559d..c2010ce82 100644
--- a/tests/unit/out/refcount/expr_as_bool_c.rs
+++ b/tests/unit/out/refcount/expr_as_bool_c.rs
@@ -22,6 +22,7 @@ pub fn both_null_2(s1: Ptr<u8>, s2: Ptr<u8>) -> i32 {
         && ((((*s2.borrow()).is_null()) as i32) != 0)) as i32);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -90,3 +91,4 @@ fn main_0() -> i32 {
     assert!((((({ both_null_2((*p1.borrow()).clone(), Ptr::<u8>::null(),) }) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/expr_as_bool_cpp.rs b/tests/unit/out/refcount/expr_as_bool_cpp.rs
index 17a64cba0..62dff945f 100644
--- a/tests/unit/out/refcount/expr_as_bool_cpp.rs
+++ b/tests/unit/out/refcount/expr_as_bool_cpp.rs
@@ -21,6 +21,7 @@ pub fn both_null_2(s1: Ptr<u8>, s2: Ptr<u8>) -> i32 {
     return ((((*s1.borrow()).is_null()) && ((*s2.borrow()).is_null())) as i32);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -84,3 +85,4 @@ fn main_0() -> i32 {
     assert!((({ both_null_2((*p1.borrow()).clone(), Ptr::<u8>::null(),) }) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/exprs.rs b/tests/unit/out/refcount/exprs.rs
index 8f91ffa11..98a0a6778 100644
--- a/tests/unit/out/refcount/exprs.rs
+++ b/tests/unit/out/refcount/exprs.rs
@@ -63,6 +63,7 @@ impl ByteRepr for Y {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -142,3 +143,4 @@ impl YImpl for Ptr<Y> {
         return ((*(*self).upgrade().deref()).x.as_pointer());
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fatorial.rs b/tests/unit/out/refcount/fatorial.rs
index b0846ca86..0200a7dbf 100644
--- a/tests/unit/out/refcount/fatorial.rs
+++ b/tests/unit/out/refcount/fatorial.rs
@@ -47,6 +47,7 @@ pub fn fatorial_by_ptr_2(n: Ptr<i32>) {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -57,3 +58,4 @@ fn main_0() -> i32 {
     assert!((({ fatorial_0((*n.borrow()),) }) == 720));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fcall.rs b/tests/unit/out/refcount/fcall.rs
index 2ee7a8b2a..e4d4844cd 100644
--- a/tests/unit/out/refcount/fcall.rs
+++ b/tests/unit/out/refcount/fcall.rs
@@ -43,9 +43,11 @@ pub fn f1_2(x: f64, y: f64) -> f64 {
     return ({ f2_0((*z1.borrow()), (*x.borrow())) });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ f1_2(1.0E+0, 2.0E+0,) }) == (-6_i32 as f64)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fcntl.rs b/tests/unit/out/refcount/fcntl.rs
index 7b8bf8ad1..599e45793 100644
--- a/tests/unit/out/refcount/fcntl.rs
+++ b/tests/unit/out/refcount/fcntl.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -249,3 +250,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(1) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fd_io.rs b/tests/unit/out/refcount/fd_io.rs
index f12727727..fe26b25b4 100644
--- a/tests/unit/out/refcount/fd_io.rs
+++ b/tests/unit/out/refcount/fd_io.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -140,3 +141,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fd_set_macros.rs b/tests/unit/out/refcount/fd_set_macros.rs
index ac09139a7..0f8847e58 100644
--- a/tests/unit/out/refcount/fd_set_macros.rs
+++ b/tests/unit/out/refcount/fd_set_macros.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -39,3 +40,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fflush_null.rs b/tests/unit/out/refcount/fflush_null.rs
index b9314f492..e866b7b1b 100644
--- a/tests/unit/out/refcount/fflush_null.rs
+++ b/tests/unit/out/refcount/fflush_null.rs
@@ -7,9 +7,11 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     let file_ptr: Value<Ptr<CFile>> = Rc::new(RefCell::new(Ptr::null()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fft.rs b/tests/unit/out/refcount/fft.rs
index 40b783543..09ee323ff 100644
--- a/tests/unit/out/refcount/fft.rs
+++ b/tests/unit/out/refcount/fft.rs
@@ -225,6 +225,7 @@ pub fn fft_3(a: Ptr<Option<Value<Box<[Complex]>>>>, N: i32) -> Option<Value<Box<
     return (*y.borrow_mut()).take();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -284,3 +285,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/find.rs b/tests/unit/out/refcount/find.rs
index b2c8507c0..743ea1c2a 100644
--- a/tests/unit/out/refcount/find.rs
+++ b/tests/unit/out/refcount/find.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -79,3 +80,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr.rs b/tests/unit/out/refcount/fn_ptr.rs
index ec6c2d09f..b8dfde3a9 100644
--- a/tests/unit/out/refcount/fn_ptr.rs
+++ b/tests/unit/out/refcount/fn_ptr.rs
@@ -16,6 +16,7 @@ pub fn foo_1(fn_: FnPtr<fn(AnyPtr) -> i32>, pi: Ptr<i32>) -> i32 {
     return ({ (*(*fn_.borrow()))(((*pi.borrow()).clone() as Ptr<i32>).to_any()) });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -39,3 +40,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_arity.rs b/tests/unit/out/refcount/fn_ptr_arity.rs
index 4e3dfd71b..184843192 100644
--- a/tests/unit/out/refcount/fn_ptr_arity.rs
+++ b/tests/unit/out/refcount/fn_ptr_arity.rs
@@ -39,6 +39,7 @@ pub fn foo_0(
     return 22;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -53,3 +54,4 @@ fn main_0() -> i32 {
     assert!((({ (*(*f.borrow()))(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,) }) == 22));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_array.rs b/tests/unit/out/refcount/fn_ptr_array.rs
index df1347fc9..cffe7c6f2 100644
--- a/tests/unit/out/refcount/fn_ptr_array.rs
+++ b/tests/unit/out/refcount/fn_ptr_array.rs
@@ -22,6 +22,7 @@ pub fn mul_2(a: i32, b: i32) -> i32 {
     return ((*a.borrow()) * (*b.borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -38,3 +39,4 @@ fn main_0() -> i32 {
     assert!(((*ops.borrow())[(0) as usize] != FnPtr::<fn(i32, i32) -> i32>::new(sub_1)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_as_condition.rs b/tests/unit/out/refcount/fn_ptr_as_condition.rs
index c8d7b5ce8..9f6857a3d 100644
--- a/tests/unit/out/refcount/fn_ptr_as_condition.rs
+++ b/tests/unit/out/refcount/fn_ptr_as_condition.rs
@@ -21,6 +21,7 @@ pub fn maybe_call_1(cb: FnPtr<fn(Ptr<i32>)>, x: Ptr<i32>) {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     assert!(((*c.borrow()) == 6));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_cast.rs b/tests/unit/out/refcount/fn_ptr_cast.rs
index 4d309ef6c..28e71fbb7 100644
--- a/tests/unit/out/refcount/fn_ptr_cast.rs
+++ b/tests/unit/out/refcount/fn_ptr_cast.rs
@@ -100,6 +100,7 @@ pub fn test_call_through_cast_5() {
     assert!(((*result.borrow()) == 142));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -109,3 +110,4 @@ fn main_0() -> i32 {
     ({ test_call_through_cast_5() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_conditional.rs b/tests/unit/out/refcount/fn_ptr_conditional.rs
index e25fd186c..6dbda4b07 100644
--- a/tests/unit/out/refcount/fn_ptr_conditional.rs
+++ b/tests/unit/out/refcount/fn_ptr_conditional.rs
@@ -42,6 +42,7 @@ pub fn apply_4(fn_: FnPtr<fn(i32) -> i32>, x: i32) -> i32 {
     return ({ (*(*actual.borrow()))((*x.borrow())) });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -52,3 +53,4 @@ fn main_0() -> i32 {
     assert!((({ apply_4(FnPtr::<fn(i32) -> i32>::null(), 5,) }) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_default_arg.rs b/tests/unit/out/refcount/fn_ptr_default_arg.rs
index 0348fc828..7e5a0bb3d 100644
--- a/tests/unit/out/refcount/fn_ptr_default_arg.rs
+++ b/tests/unit/out/refcount/fn_ptr_default_arg.rs
@@ -20,6 +20,7 @@ pub fn apply_1(x: i32, fn_: Option<FnPtr<fn(i32) -> i32>>) -> i32 {
     return (*x.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     assert!((({ apply_1(5, Some((*negate.borrow()).clone()),) }) == -5_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_global.rs b/tests/unit/out/refcount/fn_ptr_global.rs
index 47af3b84f..39780d3c0 100644
--- a/tests/unit/out/refcount/fn_ptr_global.rs
+++ b/tests/unit/out/refcount/fn_ptr_global.rs
@@ -30,6 +30,7 @@ pub fn call_op_4(x: i32) -> i32 {
     return (*x.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -52,3 +53,6 @@ fn main_0() -> i32 {
     assert!((({ call_op_4(5,) }) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = g_op_2.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/fn_ptr_reassign.rs b/tests/unit/out/refcount/fn_ptr_reassign.rs
index ce04bf24e..5be70941b 100644
--- a/tests/unit/out/refcount/fn_ptr_reassign.rs
+++ b/tests/unit/out/refcount/fn_ptr_reassign.rs
@@ -22,6 +22,7 @@ pub fn mul_2(a: i32, b: i32) -> i32 {
     return ((*a.borrow()) * (*b.borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -39,3 +40,4 @@ fn main_0() -> i32 {
     assert!((({ (*(*fn_.borrow()))(1, 1,) }) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_return.rs b/tests/unit/out/refcount/fn_ptr_return.rs
index 5fc0dfaf0..5d14ed5c9 100644
--- a/tests/unit/out/refcount/fn_ptr_return.rs
+++ b/tests/unit/out/refcount/fn_ptr_return.rs
@@ -22,6 +22,7 @@ pub fn pick_2(choose_inc: i32) -> FnPtr<fn(i32) -> i32> {
     return FnPtr::<fn(i32) -> i32>::new(dec_1);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -44,3 +45,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_stable_sort.rs b/tests/unit/out/refcount/fn_ptr_stable_sort.rs
index be45ffe6f..7b03be224 100644
--- a/tests/unit/out/refcount/fn_ptr_stable_sort.rs
+++ b/tests/unit/out/refcount/fn_ptr_stable_sort.rs
@@ -43,6 +43,7 @@ pub fn Compare_0(a: Ptr<Item>, b: Ptr<Item>) -> bool {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -92,3 +93,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs b/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs
index b809e1870..69de8ca10 100644
--- a/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs
+++ b/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs
@@ -21,6 +21,7 @@ pub fn my_alternative_fwrite_1(p: Ptr<u8>, n: usize, m: usize, f: AnyPtr) -> usi
     return 33_usize;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -271,3 +272,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_struct.rs b/tests/unit/out/refcount/fn_ptr_struct.rs
index 29dc5c656..591311fb2 100644
--- a/tests/unit/out/refcount/fn_ptr_struct.rs
+++ b/tests/unit/out/refcount/fn_ptr_struct.rs
@@ -55,6 +55,7 @@ pub fn negate_1(x: i32) -> i32 {
     return -(*x.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -77,3 +78,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_void_return.rs b/tests/unit/out/refcount/fn_ptr_void_return.rs
index d68c8967e..4779ebc24 100644
--- a/tests/unit/out/refcount/fn_ptr_void_return.rs
+++ b/tests/unit/out/refcount/fn_ptr_void_return.rs
@@ -21,6 +21,7 @@ pub fn run_2(fn_: FnPtr<fn(Ptr<i32>)>, x: Ptr<i32>) {
     ({ (*(*fn_.borrow()))((*x.borrow()).clone()) });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -37,3 +38,4 @@ fn main_0() -> i32 {
     assert!(((*b.borrow()) == -10_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_vtable.rs b/tests/unit/out/refcount/fn_ptr_vtable.rs
index dab4ed34c..043c1d337 100644
--- a/tests/unit/out/refcount/fn_ptr_vtable.rs
+++ b/tests/unit/out/refcount/fn_ptr_vtable.rs
@@ -70,6 +70,7 @@ pub fn int_destroy_3(p: AnyPtr) {
     (*p.borrow()).reinterpret_cast::<i32>().write(0);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -89,3 +90,6 @@ fn main_0() -> i32 {
     assert!((*(*vt.borrow()).get.borrow()).is_null());
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = storage_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/fopen.rs b/tests/unit/out/refcount/fopen.rs
index d8c30f4fd..972ff7c9e 100644
--- a/tests/unit/out/refcount/fopen.rs
+++ b/tests/unit/out/refcount/fopen.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -23,3 +24,4 @@ fn main_0() -> i32 {
     ));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach.rs b/tests/unit/out/refcount/foreach.rs
index 74d3697cb..8587f2e19 100644
--- a/tests/unit/out/refcount/foreach.rs
+++ b/tests/unit/out/refcount/foreach.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -27,3 +28,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 45));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
index ce6419efa..8f80d5289 100644
--- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
+++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
@@ -37,6 +37,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -48,3 +49,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_double.rs b/tests/unit/out/refcount/foreach_double.rs
index 7766ac69c..a1ca4597f 100644
--- a/tests/unit/out/refcount/foreach_double.rs
+++ b/tests/unit/out/refcount/foreach_double.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -72,3 +73,4 @@ fn main_0() -> i32 {
     assert!(((*square.borrow()) == 144));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs
index 2fd932604..ca3f4901c 100644
--- a/tests/unit/out/refcount/foreach_map.rs
+++ b/tests/unit/out/refcount/foreach_map.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 7475_f64));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_mut.rs b/tests/unit/out/refcount/foreach_mut.rs
index 09ffe44e3..73e040bab 100644
--- a/tests/unit/out/refcount/foreach_mut.rs
+++ b/tests/unit/out/refcount/foreach_mut.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -64,3 +65,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 168));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/friend.rs b/tests/unit/out/refcount/friend.rs
index 5fc9b0adb..138afba71 100644
--- a/tests/unit/out/refcount/friend.rs
+++ b/tests/unit/out/refcount/friend.rs
@@ -154,6 +154,7 @@ pub fn declared_then_defined_6(d: Ptr<D>) -> i32 {
     return ((*(*d.upgrade().deref()).x.borrow()) + 1);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -195,3 +196,4 @@ fn main_0() -> i32 {
     assert!((({ declared_then_defined_6(d.as_pointer(),) }) == 8));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fstat.rs b/tests/unit/out/refcount/fstat.rs
index 86bf4c31d..d932b694f 100644
--- a/tests/unit/out/refcount/fstat.rs
+++ b/tests/unit/out/refcount/fstat.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -76,3 +77,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/function_call.rs b/tests/unit/out/refcount/function_call.rs
index b66416338..2f7f61bbb 100644
--- a/tests/unit/out/refcount/function_call.rs
+++ b/tests/unit/out/refcount/function_call.rs
@@ -13,6 +13,7 @@ pub fn function_0(y: i32, z: i32) -> i32 {
     return (((*x.borrow()) + (*y.borrow())) + (*z.borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     assert!(((*y.borrow()) == 16));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/function_overloading.rs b/tests/unit/out/refcount/function_overloading.rs
index 55cdb27ad..e720b72b7 100644
--- a/tests/unit/out/refcount/function_overloading.rs
+++ b/tests/unit/out/refcount/function_overloading.rs
@@ -63,6 +63,7 @@ pub fn func_6(x: Ptr<i32>) -> i32 {
     return 1;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -119,3 +120,4 @@ impl FooImpl for Ptr<Foo> {
         let y: Value<f64> = Rc::new(RefCell::new(y));
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/global-initialization-using-global.rs b/tests/unit/out/refcount/global-initialization-using-global.rs
index e207d7961..2fffecc6d 100644
--- a/tests/unit/out/refcount/global-initialization-using-global.rs
+++ b/tests/unit/out/refcount/global-initialization-using-global.rs
@@ -14,6 +14,7 @@ thread_local!(
         Rc::new(RefCell::new(((*first_0.with(Value::clone).borrow()) + 1)));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -23,3 +24,7 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = first_0.with(Value::clone);
+    let _ = second_1.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/global_init_side_effect.rs b/tests/unit/out/refcount/global_init_side_effect.rs
index 3610845b0..7bada4ce5 100644
--- a/tests/unit/out/refcount/global_init_side_effect.rs
+++ b/tests/unit/out/refcount/global_init_side_effect.rs
@@ -43,9 +43,15 @@ thread_local!(
     pub static b_2: Value<S> = Rc::new(RefCell::new(S::S({ 10 })));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!(((*total_0.with(Value::clone).borrow()) == 11));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = total_0.with(Value::clone);
+    let _ = a_1.with(Value::clone);
+    let _ = b_2.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/global_non_const_init.rs b/tests/unit/out/refcount/global_non_const_init.rs
index 60f5f8566..b40c3230e 100644
--- a/tests/unit/out/refcount/global_non_const_init.rs
+++ b/tests/unit/out/refcount/global_non_const_init.rs
@@ -178,6 +178,7 @@ impl ByteRepr for Singleton {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -216,3 +217,14 @@ fn main_0() -> i32 {
     assert!((({ Singleton::instance() }) == ({ Singleton::instance() })));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = signature_3.with(Value::clone);
+    let _ = single_4.with(Value::clone);
+    let _ = from_call_5.with(Value::clone);
+    let _ = depends_on_call_6.with(Value::clone);
+    let _ = default_ctor_7.with(Value::clone);
+    let _ = arg_ctor_8.with(Value::clone);
+    let _ = str_9.with(Value::clone);
+    let _ = inline_member_11.with(Value::clone);
+    let _ = member_10.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/global_pointers.rs b/tests/unit/out/refcount/global_pointers.rs
index a3ee9fdab..f560b081d 100644
--- a/tests/unit/out/refcount/global_pointers.rs
+++ b/tests/unit/out/refcount/global_pointers.rs
@@ -62,6 +62,7 @@ thread_local!(
     ])));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -81,3 +82,8 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = single_entry_0.with(Value::clone);
+    let _ = entries_1.with(Value::clone);
+    let _ = arr_of_pointers_2.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/global_without_initializer.rs b/tests/unit/out/refcount/global_without_initializer.rs
index 0abcd1dfa..9d778b8e6 100644
--- a/tests/unit/out/refcount/global_without_initializer.rs
+++ b/tests/unit/out/refcount/global_without_initializer.rs
@@ -42,6 +42,7 @@ thread_local!(
     pub static size_2: Value<usize> = Rc::new(RefCell::new(0_usize));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -50,3 +51,8 @@ fn main_0() -> i32 {
     assert!(((*size_2.with(Value::clone).borrow()) == 0_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = s_0.with(Value::clone);
+    let _ = file_1.with(Value::clone);
+    let _ = size_2.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/goto_aggregate_default.rs b/tests/unit/out/refcount/goto_aggregate_default.rs
index 506316fd2..32d6e671a 100644
--- a/tests/unit/out/refcount/goto_aggregate_default.rs
+++ b/tests/unit/out/refcount/goto_aggregate_default.rs
@@ -68,6 +68,7 @@ pub fn agg_0(n: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -75,3 +76,4 @@ fn main_0() -> i32 {
     assert!((((({ agg_0(1,) }) == 1) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/goto_backward.rs b/tests/unit/out/refcount/goto_backward.rs
index fa72c1fb0..005d54ad6 100644
--- a/tests/unit/out/refcount/goto_backward.rs
+++ b/tests/unit/out/refcount/goto_backward.rs
@@ -27,9 +27,11 @@ pub fn retry_0(n: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((((({ retry_0(4,) }) == 12) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/goto_cleanup.rs b/tests/unit/out/refcount/goto_cleanup.rs
index baa003ecd..03f91b501 100644
--- a/tests/unit/out/refcount/goto_cleanup.rs
+++ b/tests/unit/out/refcount/goto_cleanup.rs
@@ -155,6 +155,7 @@ pub fn via_arrays_4(fail: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -174,3 +175,4 @@ fn main_0() -> i32 {
     assert!((((({ via_arrays_4(1,) }) == -1_i32) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/goto_loop_control.rs b/tests/unit/out/refcount/goto_loop_control.rs
index 61e0486ee..a77037adc 100644
--- a/tests/unit/out/refcount/goto_loop_control.rs
+++ b/tests/unit/out/refcount/goto_loop_control.rs
@@ -30,9 +30,11 @@ pub fn loopctl_0() -> i32 {
     return (*sum.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((((({ loopctl_0() }) == 3) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/goto_multi_label.rs b/tests/unit/out/refcount/goto_multi_label.rs
index 6826fea2f..49dadcda1 100644
--- a/tests/unit/out/refcount/goto_multi_label.rs
+++ b/tests/unit/out/refcount/goto_multi_label.rs
@@ -31,6 +31,7 @@ pub fn classify_0(n: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -39,3 +40,4 @@ fn main_0() -> i32 {
     assert!((((({ classify_0(-2_i32,) }) == -1_i32) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/goto_nested_label.rs b/tests/unit/out/refcount/goto_nested_label.rs
index de16925c1..53418344d 100644
--- a/tests/unit/out/refcount/goto_nested_label.rs
+++ b/tests/unit/out/refcount/goto_nested_label.rs
@@ -33,9 +33,11 @@ pub fn scan_0(n: i32) -> i32 {
     return (*total.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((((({ scan_0(2,) }) == 2010) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/goto_switch_fallthrough.rs b/tests/unit/out/refcount/goto_switch_fallthrough.rs
index 579cb5151..1b4cb78dc 100644
--- a/tests/unit/out/refcount/goto_switch_fallthrough.rs
+++ b/tests/unit/out/refcount/goto_switch_fallthrough.rs
@@ -34,6 +34,7 @@ pub fn sm_0(n: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,4 @@ fn main_0() -> i32 {
     assert!((((({ sm_0(9,) }) == 1100) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/goto_switch_self_case.rs b/tests/unit/out/refcount/goto_switch_self_case.rs
index 86c3a7de6..1a272a911 100644
--- a/tests/unit/out/refcount/goto_switch_self_case.rs
+++ b/tests/unit/out/refcount/goto_switch_self_case.rs
@@ -26,6 +26,7 @@ pub fn sm_0(n: i32) -> i32 {
     return (*steps.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     assert!((((({ sm_0(7,) }) == -1_i32) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/huffman.rs b/tests/unit/out/refcount/huffman.rs
index 0b622cb5f..8058ba515 100644
--- a/tests/unit/out/refcount/huffman.rs
+++ b/tests/unit/out/refcount/huffman.rs
@@ -279,6 +279,7 @@ pub fn HuffmanCodes_5(
     return (*out.borrow_mut()).take();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -516,3 +517,4 @@ impl MinHeapNodeImpl for Ptr<MinHeapNode> {
             && ((*(*(*self).upgrade().deref()).right.borrow()).is_null());
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ifaddrs.rs b/tests/unit/out/refcount/ifaddrs.rs
index 20dc87a98..78f966e19 100644
--- a/tests/unit/out/refcount/ifaddrs.rs
+++ b/tests/unit/out/refcount/ifaddrs.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -161,3 +162,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ignored_rule.rs b/tests/unit/out/refcount/ignored_rule.rs
index b2affb4a0..b5e5a9f0d 100644
--- a/tests/unit/out/refcount/ignored_rule.rs
+++ b/tests/unit/out/refcount/ignored_rule.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     ])));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/immutable-deref-on-func-call.rs b/tests/unit/out/refcount/immutable-deref-on-func-call.rs
index e36f541c7..7104984b5 100644
--- a/tests/unit/out/refcount/immutable-deref-on-func-call.rs
+++ b/tests/unit/out/refcount/immutable-deref-on-func-call.rs
@@ -33,6 +33,7 @@ impl ByteRepr for Item {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -72,3 +73,4 @@ impl ItemImpl for Ptr<Item> {
         (*(*(*other.borrow()).upgrade().deref()).value.borrow_mut()) = 10;
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/immutable_unsigned_arithmetic.rs b/tests/unit/out/refcount/immutable_unsigned_arithmetic.rs
index fcceaf175..fe53b0044 100644
--- a/tests/unit/out/refcount/immutable_unsigned_arithmetic.rs
+++ b/tests/unit/out/refcount/immutable_unsigned_arithmetic.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     };
     return (((*p.borrow()).read()) as i32);
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/implicit_autoref.rs b/tests/unit/out/refcount/implicit_autoref.rs
index d8e45de83..d1b9c47e6 100644
--- a/tests/unit/out/refcount/implicit_autoref.rs
+++ b/tests/unit/out/refcount/implicit_autoref.rs
@@ -37,6 +37,7 @@ pub fn write_through_0(p: Ptr<i32>) {
     (*p.borrow()).write(42);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -91,3 +92,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/implicit_ptr_cast.rs b/tests/unit/out/refcount/implicit_ptr_cast.rs
index 135bffd5f..c33c67533 100644
--- a/tests/unit/out/refcount/implicit_ptr_cast.rs
+++ b/tests/unit/out/refcount/implicit_ptr_cast.rs
@@ -11,6 +11,7 @@ pub fn write_ulong_0(p: Ptr<u64>) {
     (*p.borrow()).write(42_u64);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!(((((*x.borrow()) == 42_usize) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/inet_pton_ntop.rs b/tests/unit/out/refcount/inet_pton_ntop.rs
index 2394ba929..8964ac63d 100644
--- a/tests/unit/out/refcount/inet_pton_ntop.rs
+++ b/tests/unit/out/refcount/inet_pton_ntop.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -382,3 +383,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/init.rs b/tests/unit/out/refcount/init.rs
index 211f3de2b..5093edcd8 100644
--- a/tests/unit/out/refcount/init.rs
+++ b/tests/unit/out/refcount/init.rs
@@ -36,6 +36,7 @@ pub fn func_0() -> i32 {
     return 42;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -56,3 +57,4 @@ fn main_0() -> i32 {
     (*aa.borrow_mut()) = ({ func_0() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/init_list.rs b/tests/unit/out/refcount/init_list.rs
index 4913029aa..3de38b43f 100644
--- a/tests/unit/out/refcount/init_list.rs
+++ b/tests/unit/out/refcount/init_list.rs
@@ -10,6 +10,7 @@ pub fn f_0(list: Vec<i32>) {
     let list: Value<Vec<i32>> = Rc::new(RefCell::new(list));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     ({ f_0(vec![1, 2, 3, 4]) });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/initializer_list.rs b/tests/unit/out/refcount/initializer_list.rs
index f7684c192..7fe256082 100644
--- a/tests/unit/out/refcount/initializer_list.rs
+++ b/tests/unit/out/refcount/initializer_list.rs
@@ -14,9 +14,11 @@ pub fn f_0(bytes: Vec<i32>) -> usize {
     return (*n.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ f_0(vec![1, 2, 3,],) }) == 3_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/int_to_bool_explicit.rs b/tests/unit/out/refcount/int_to_bool_explicit.rs
index 4024521f5..08898fd44 100644
--- a/tests/unit/out/refcount/int_to_bool_explicit.rs
+++ b/tests/unit/out/refcount/int_to_bool_explicit.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -17,3 +18,4 @@ fn main_0() -> i32 {
     assert!(!(*b2.borrow()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/int_to_bool_explicit_c.rs b/tests/unit/out/refcount/int_to_bool_explicit_c.rs
index 0bd69774c..b8aa47cef 100644
--- a/tests/unit/out/refcount/int_to_bool_explicit_c.rs
+++ b/tests/unit/out/refcount/int_to_bool_explicit_c.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -17,3 +18,4 @@ fn main_0() -> i32 {
     assert!(((!(*b2.borrow()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ipproto_macros.rs b/tests/unit/out/refcount/ipproto_macros.rs
index c97265a33..e58255f7a 100644
--- a/tests/unit/out/refcount/ipproto_macros.rs
+++ b/tests/unit/out/refcount/ipproto_macros.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -17,3 +18,4 @@ fn main_0() -> i32 {
     assert!((((((*tcp.borrow()) + (*udp.borrow())) + (*ip.borrow())) + (*ip6.borrow())) == 64));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/isatty.rs b/tests/unit/out/refcount/isatty.rs
index 8f33ed92c..6b75dba6d 100644
--- a/tests/unit/out/refcount/isatty.rs
+++ b/tests/unit/out/refcount/isatty.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -56,3 +57,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/iterator_freshness.rs b/tests/unit/out/refcount/iterator_freshness.rs
index c626df1e7..278f38085 100644
--- a/tests/unit/out/refcount/iterator_freshness.rs
+++ b/tests/unit/out/refcount/iterator_freshness.rs
@@ -10,6 +10,7 @@ pub fn foo_0(a0: Ptr<i32>) {
     let a0: Value<Ptr<i32>> = Rc::new(RefCell::new(a0));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
     ({ foo_0((*it.borrow()).clone()) });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/iterators.rs b/tests/unit/out/refcount/iterators.rs
index 542289110..fa6e8aaad 100644
--- a/tests/unit/out/refcount/iterators.rs
+++ b/tests/unit/out/refcount/iterators.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/keywords.rs b/tests/unit/out/refcount/keywords.rs
index 1a5e82b57..ce755f9a2 100644
--- a/tests/unit/out/refcount/keywords.rs
+++ b/tests/unit/out/refcount/keywords.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     assert!(((*in_.borrow()) == 123));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/kruskal.rs b/tests/unit/out/refcount/kruskal.rs
index de5b50f36..70718b45f 100644
--- a/tests/unit/out/refcount/kruskal.rs
+++ b/tests/unit/out/refcount/kruskal.rs
@@ -328,6 +328,7 @@ pub fn MSTKruskal_2(graph: Ptr<Graph>) -> f64 {
     return (*total_weight.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -487,3 +488,4 @@ impl DisjointSetImpl for Ptr<DisjointSet> {
         }
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/lambda_capture_pass.rs b/tests/unit/out/refcount/lambda_capture_pass.rs
index 378003b70..ad5347557 100644
--- a/tests/unit/out/refcount/lambda_capture_pass.rs
+++ b/tests/unit/out/refcount/lambda_capture_pass.rs
@@ -17,6 +17,7 @@ pub fn apply_1(fn_: impl Fn(i32) -> i32, x: i32) -> i32 {
     return ({ (*fn_.borrow_mut())((*x.borrow())) });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!((({ apply_1((*scale.borrow()).clone(), 4,) }) == 12));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/lambda_nested.rs b/tests/unit/out/refcount/lambda_nested.rs
index a1e03c779..29670d7b9 100644
--- a/tests/unit/out/refcount/lambda_nested.rs
+++ b/tests/unit/out/refcount/lambda_nested.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     assert!((({ (*outer.borrow_mut())(20,) }) == 121));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/libc_char_ptr_field.rs b/tests/unit/out/refcount/libc_char_ptr_field.rs
index ac3719fb5..10679e8e9 100644
--- a/tests/unit/out/refcount/libc_char_ptr_field.rs
+++ b/tests/unit/out/refcount/libc_char_ptr_field.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -56,3 +57,4 @@ fn main_0() -> i32 {
     ));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/libc_struct_without_default.rs b/tests/unit/out/refcount/libc_struct_without_default.rs
index 2c59eebde..dd6ab382d 100644
--- a/tests/unit/out/refcount/libc_struct_without_default.rs
+++ b/tests/unit/out/refcount/libc_struct_without_default.rs
@@ -80,6 +80,7 @@ impl ByteRepr for FieldIsLibcType {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -115,3 +116,4 @@ fn main_0() -> i32 {
     assert!((((*(*(*filt.borrow()).addr.borrow()).sa_family.borrow()) as i32) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/linked_list.rs b/tests/unit/out/refcount/linked_list.rs
index f68374b8b..146005808 100644
--- a/tests/unit/out/refcount/linked_list.rs
+++ b/tests/unit/out/refcount/linked_list.rs
@@ -81,6 +81,7 @@ pub fn Delete_2(head: Ptr<Node>, val: i32) -> Ptr<Node> {
     return (*head.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -192,3 +193,4 @@ impl NodeImpl for Ptr<Node> {
         (*(*(*self).upgrade().deref()).next.borrow_mut()) = (*next.borrow()).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/local_anon_struct_collision.rs b/tests/unit/out/refcount/local_anon_struct_collision.rs
index d717fab0d..18412f41c 100644
--- a/tests/unit/out/refcount/local_anon_struct_collision.rs
+++ b/tests/unit/out/refcount/local_anon_struct_collision.rs
@@ -75,6 +75,7 @@ pub fn second_2() -> i32 {
     return (((*(*q.borrow()).a.borrow()) + (*(*q.borrow()).b.borrow())) as i32);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -82,3 +83,4 @@ fn main_0() -> i32 {
     assert!((((({ second_2() }) == 30) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/loop_with_postfix_inc.rs b/tests/unit/out/refcount/loop_with_postfix_inc.rs
index 2965f6f51..79fbf076b 100644
--- a/tests/unit/out/refcount/loop_with_postfix_inc.rs
+++ b/tests/unit/out/refcount/loop_with_postfix_inc.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -17,3 +18,4 @@ fn main_0() -> i32 {
     assert!(((*x.borrow()) == 101));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/lseek_ftruncate.rs b/tests/unit/out/refcount/lseek_ftruncate.rs
index 5da75c3cf..ded3a588a 100644
--- a/tests/unit/out/refcount/lseek_ftruncate.rs
+++ b/tests/unit/out/refcount/lseek_ftruncate.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -174,3 +175,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/lvalue_ref_goto.rs b/tests/unit/out/refcount/lvalue_ref_goto.rs
index 88ef0ac86..ab483dd4f 100644
--- a/tests/unit/out/refcount/lvalue_ref_goto.rs
+++ b/tests/unit/out/refcount/lvalue_ref_goto.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     });
     panic!("ub: non-void function does not return a value")
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/macros.rs b/tests/unit/out/refcount/macros.rs
index 6a3505512..927b5ec12 100644
--- a/tests/unit/out/refcount/macros.rs
+++ b/tests/unit/out/refcount/macros.rs
@@ -18,6 +18,7 @@ pub fn log_0(file: Ptr<u8>, line: i32, func: Ptr<u8>) {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -36,3 +37,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/main.rs b/tests/unit/out/refcount/main.rs
index 0115435f0..fa3cdee66 100644
--- a/tests/unit/out/refcount/main.rs
+++ b/tests/unit/out/refcount/main.rs
@@ -20,6 +20,7 @@ pub fn main() {
             .collect(),
     ));
     (*argv.borrow_mut()).push(Ptr::null());
+    __cpp2rust_init_globals();
     ::std::process::exit(main_0(::std::env::args().len() as i32, argv.as_pointer()));
 }
 fn main_0(argc: i32, argv: Ptr<Ptr<u8>>) -> i32 {
@@ -36,3 +37,4 @@ fn main_0(argc: i32, argv: Ptr<Ptr<u8>>) -> i32 {
     assert!((((*argc.borrow()) + ((((*s.borrow()).len() - 1) > 0_usize) as i32)) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/malloc_realloc_free.rs b/tests/unit/out/refcount/malloc_realloc_free.rs
index d07cebe55..632c4701e 100644
--- a/tests/unit/out/refcount/malloc_realloc_free.rs
+++ b/tests/unit/out/refcount/malloc_realloc_free.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -149,3 +150,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs
index 72572fd3a..5c6852566 100644
--- a/tests/unit/out/refcount/map-reallocation.rs
+++ b/tests/unit/out/refcount/map-reallocation.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -104,3 +105,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs
index 77707d781..64b91b0d4 100644
--- a/tests/unit/out/refcount/map.rs
+++ b/tests/unit/out/refcount/map.rs
@@ -16,6 +16,7 @@ pub fn bar_1(x: Ptr<u32>) {
     x.write(__rhs);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -410,3 +411,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/matmul.rs b/tests/unit/out/refcount/matmul.rs
index 0d7d95502..f9dd26a5c 100644
--- a/tests/unit/out/refcount/matmul.rs
+++ b/tests/unit/out/refcount/matmul.rs
@@ -90,6 +90,7 @@ pub fn matmul_1(
     return (*m3.borrow_mut()).take();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -121,3 +122,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/max.rs b/tests/unit/out/refcount/max.rs
index e6f700913..e71c226e8 100644
--- a/tests/unit/out/refcount/max.rs
+++ b/tests/unit/out/refcount/max.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -65,3 +66,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memcpy_overlap.rs b/tests/unit/out/refcount/memcpy_overlap.rs
index 821853c50..02db711b8 100644
--- a/tests/unit/out/refcount/memcpy_overlap.rs
+++ b/tests/unit/out/refcount/memcpy_overlap.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -31,3 +32,4 @@ fn main_0() -> i32 {
     assert!((((*buf.borrow())[(5) as usize] as i32) == 4));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memcpy_struct_bytes.rs b/tests/unit/out/refcount/memcpy_struct_bytes.rs
index e141580f6..629f2e7b9 100644
--- a/tests/unit/out/refcount/memcpy_struct_bytes.rs
+++ b/tests/unit/out/refcount/memcpy_struct_bytes.rs
@@ -35,6 +35,7 @@ impl ByteRepr for point {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -64,3 +65,4 @@ fn main_0() -> i32 {
     assert!(((((*(*dst.borrow()).y.borrow()) == 7) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memcpy_struct_struct.rs b/tests/unit/out/refcount/memcpy_struct_struct.rs
index 84575f4d6..5e7d58fc5 100644
--- a/tests/unit/out/refcount/memcpy_struct_struct.rs
+++ b/tests/unit/out/refcount/memcpy_struct_struct.rs
@@ -37,6 +37,7 @@ impl ByteRepr for Entry {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -104,3 +105,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memset.rs b/tests/unit/out/refcount/memset.rs
index b36cf8b35..2d07857e3 100644
--- a/tests/unit/out/refcount/memset.rs
+++ b/tests/unit/out/refcount/memset.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 50529027));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/min_max_ptr2ptr.rs b/tests/unit/out/refcount/min_max_ptr2ptr.rs
index 6cf409db9..441e2fc30 100644
--- a/tests/unit/out/refcount/min_max_ptr2ptr.rs
+++ b/tests/unit/out/refcount/min_max_ptr2ptr.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     assert!((((*r1.borrow()) + (*r2.borrow())) == 30));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/move_assign.rs b/tests/unit/out/refcount/move_assign.rs
index 9a69f38a7..a37b59de7 100644
--- a/tests/unit/out/refcount/move_assign.rs
+++ b/tests/unit/out/refcount/move_assign.rs
@@ -78,6 +78,7 @@ pub fn make_0(v: i32) -> MoveOnly {
     return MoveOnly::MoveOnly_pmutMoveOnly({ m.as_pointer() });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -188,3 +189,4 @@ impl MoveOnlyImpl for Ptr<MoveOnly> {
         return (*self).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/move_ctor.rs b/tests/unit/out/refcount/move_ctor.rs
index 7a8cbadb8..77ba25aaa 100644
--- a/tests/unit/out/refcount/move_ctor.rs
+++ b/tests/unit/out/refcount/move_ctor.rs
@@ -96,6 +96,7 @@ pub fn make_1(v: i32) -> MoveOnly {
     return MoveOnly::MoveOnly_pmutMoveOnly({ m.as_pointer() });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -153,3 +154,4 @@ fn main_0() -> i32 {
     assert!(((*(*m2.borrow()).mark.borrow()) == 10));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/move_this.rs b/tests/unit/out/refcount/move_this.rs
index 273a6e53a..aac859481 100644
--- a/tests/unit/out/refcount/move_this.rs
+++ b/tests/unit/out/refcount/move_this.rs
@@ -59,6 +59,7 @@ pub fn consume_0(c: Chain) -> i32 {
     return (*(*c.borrow()).v.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -117,3 +118,4 @@ impl ChainImpl for Ptr<Chain> {
         return (*self).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/nested_block_scope.rs b/tests/unit/out/refcount/nested_block_scope.rs
index 44fb5e25b..dd51d7348 100644
--- a/tests/unit/out/refcount/nested_block_scope.rs
+++ b/tests/unit/out/refcount/nested_block_scope.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -44,3 +45,4 @@ fn main_0() -> i32 {
     assert!(((*x.borrow()) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/nested_structs.rs b/tests/unit/out/refcount/nested_structs.rs
index 58bade839..31ba4c3eb 100644
--- a/tests/unit/out/refcount/nested_structs.rs
+++ b/tests/unit/out/refcount/nested_structs.rs
@@ -163,6 +163,7 @@ impl ByteRepr for Level0 {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -187,3 +188,4 @@ fn main_0() -> i32 {
         }));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/netdb.rs b/tests/unit/out/refcount/netdb.rs
index 8aea22f46..4055985d2 100644
--- a/tests/unit/out/refcount/netdb.rs
+++ b/tests/unit/out/refcount/netdb.rs
@@ -478,6 +478,7 @@ pub fn test_null_hints_2() {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -486,3 +487,4 @@ fn main_0() -> i32 {
     ({ test_null_hints_2() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/new.rs b/tests/unit/out/refcount/new.rs
index c8c701d48..002991001 100644
--- a/tests/unit/out/refcount/new.rs
+++ b/tests/unit/out/refcount/new.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     assert!(((*out.borrow()) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/new_alloc_array.rs b/tests/unit/out/refcount/new_alloc_array.rs
index 9c3a85496..63630820c 100644
--- a/tests/unit/out/refcount/new_alloc_array.rs
+++ b/tests/unit/out/refcount/new_alloc_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!(((*out.borrow()) == 99));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/new_array.rs b/tests/unit/out/refcount/new_array.rs
index b794ac55a..f6f06091c 100644
--- a/tests/unit/out/refcount/new_array.rs
+++ b/tests/unit/out/refcount/new_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     (*array.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/new_array_var_size.rs b/tests/unit/out/refcount/new_array_var_size.rs
index 149fe32ca..1b3ecc6b7 100644
--- a/tests/unit/out/refcount/new_array_var_size.rs
+++ b/tests/unit/out/refcount/new_array_var_size.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     (*A2.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/new_bst.rs b/tests/unit/out/refcount/new_bst.rs
index fdd53877b..f54de07bb 100644
--- a/tests/unit/out/refcount/new_bst.rs
+++ b/tests/unit/out/refcount/new_bst.rs
@@ -119,6 +119,7 @@ pub fn del_2(node: Ptr<node_t>) {
     (*node.borrow()).delete();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -162,3 +163,4 @@ fn main_0() -> i32 {
     assert!((*out.borrow()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/new_struct.rs b/tests/unit/out/refcount/new_struct.rs
index 4bdcf4370..85b039dbd 100644
--- a/tests/unit/out/refcount/new_struct.rs
+++ b/tests/unit/out/refcount/new_struct.rs
@@ -37,6 +37,7 @@ impl ByteRepr for Pair {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -52,3 +53,4 @@ fn main_0() -> i32 {
     assert!(((*out.borrow()) == 3));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/no_direct_callee.rs b/tests/unit/out/refcount/no_direct_callee.rs
index 9a5941ea4..ed9a17b92 100644
--- a/tests/unit/out/refcount/no_direct_callee.rs
+++ b/tests/unit/out/refcount/no_direct_callee.rs
@@ -17,9 +17,11 @@ pub fn test_1(fn_: FnPtr<fn() -> bool>) -> i32 {
     return 0;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ test_1(FnPtr::<fn() -> bool>::new(test1_0),) }) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/null_compare.rs b/tests/unit/out/refcount/null_compare.rs
index 4eec7cad7..b76f41b9f 100644
--- a/tests/unit/out/refcount/null_compare.rs
+++ b/tests/unit/out/refcount/null_compare.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!(((((*p.borrow()).is_null()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/null_in_statics.rs b/tests/unit/out/refcount/null_in_statics.rs
index 84e7f9439..f74417e5b 100644
--- a/tests/unit/out/refcount/null_in_statics.rs
+++ b/tests/unit/out/refcount/null_in_statics.rs
@@ -39,6 +39,7 @@ thread_local!(
     pub static p_zero_7: Value<Ptr<i32>> = Rc::new(RefCell::new(Ptr::<i32>::null()));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -62,3 +63,13 @@ fn main_0() -> i32 {
     assert!((*p_zero_7.with(Value::clone).borrow()).is_null());
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = p_mut_0.with(Value::clone);
+    let _ = p_const_1.with(Value::clone);
+    let _ = cp_2.with(Value::clone);
+    let _ = arr_of_ptr_3.with(Value::clone);
+    let _ = pp_4.with(Value::clone);
+    let _ = const_arr_of_ptr_5.with(Value::clone);
+    let _ = cp_explicit_null_6.with(Value::clone);
+    let _ = p_zero_7.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/offsetof.rs b/tests/unit/out/refcount/offsetof.rs
index 7d9e0f58c..07c8598ba 100644
--- a/tests/unit/out/refcount/offsetof.rs
+++ b/tests/unit/out/refcount/offsetof.rs
@@ -81,6 +81,7 @@ impl ByteRepr for Frame {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -112,3 +113,4 @@ fn main_0() -> i32 {
     assert!(((*total.borrow()) == (2_usize).wrapping_add((*len.borrow()))));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/opaque_forward_decl.rs b/tests/unit/out/refcount/opaque_forward_decl.rs
index 983539989..eccaf1602 100644
--- a/tests/unit/out/refcount/opaque_forward_decl.rs
+++ b/tests/unit/out/refcount/opaque_forward_decl.rs
@@ -35,6 +35,7 @@ impl ByteRepr for container {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -47,3 +48,4 @@ fn main_0() -> i32 {
 }
 #[derive(Clone, Copy, Default, ByteRepr)]
 pub struct opaque;
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/opaque_record_copy.rs b/tests/unit/out/refcount/opaque_record_copy.rs
index 143a36dbb..db9f94120 100644
--- a/tests/unit/out/refcount/opaque_record_copy.rs
+++ b/tests/unit/out/refcount/opaque_record_copy.rs
@@ -37,6 +37,7 @@ impl ByteRepr for Wrapper_Probe_ {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -51,3 +52,4 @@ fn main_0() -> i32 {
 }
 #[derive(Clone, Copy, Default, ByteRepr)]
 pub struct Probe;
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/opaque_then_defined.rs b/tests/unit/out/refcount/opaque_then_defined.rs
index 1c8c7a14a..8e4c56590 100644
--- a/tests/unit/out/refcount/opaque_then_defined.rs
+++ b/tests/unit/out/refcount/opaque_then_defined.rs
@@ -63,6 +63,7 @@ impl ByteRepr for node {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -84,3 +85,4 @@ fn main_0() -> i32 {
     assert!(((((*(*l.borrow()).size.borrow()) == 1) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_arithmetic_free.rs b/tests/unit/out/refcount/operator_arithmetic_free.rs
index ebbf39a7a..f36e73e57 100644
--- a/tests/unit/out/refcount/operator_arithmetic_free.rs
+++ b/tests/unit/out/refcount/operator_arithmetic_free.rs
@@ -121,6 +121,7 @@ pub fn operator_add_12(a: i32, b: Ptr<S>) -> S {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -247,3 +248,4 @@ fn main_0() -> i32 {
     assert!(((*({ operator_add_12(1, a.as_pointer(),) }).v.borrow()) == 8));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_arithmetic_member.rs b/tests/unit/out/refcount/operator_arithmetic_member.rs
index b1065522d..8a49bb27f 100644
--- a/tests/unit/out/refcount/operator_arithmetic_member.rs
+++ b/tests/unit/out/refcount/operator_arithmetic_member.rs
@@ -33,6 +33,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -199,3 +200,4 @@ impl SImpl for Ptr<S> {
         return (*old.borrow()).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_bitwise_free.rs b/tests/unit/out/refcount/operator_bitwise_free.rs
index 5a5be3f88..9a9e05310 100644
--- a/tests/unit/out/refcount/operator_bitwise_free.rs
+++ b/tests/unit/out/refcount/operator_bitwise_free.rs
@@ -80,6 +80,7 @@ pub fn operator_shr_5(a: Ptr<S>, n: i32) -> S {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -145,3 +146,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_bitwise_member.rs b/tests/unit/out/refcount/operator_bitwise_member.rs
index 8a6966d8e..416ac195b 100644
--- a/tests/unit/out/refcount/operator_bitwise_member.rs
+++ b/tests/unit/out/refcount/operator_bitwise_member.rs
@@ -33,6 +33,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -120,3 +121,4 @@ impl SImpl for Ptr<S> {
         };
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_comparison_defaulted.rs b/tests/unit/out/refcount/operator_comparison_defaulted.rs
index 8d8c3fa81..eb09a71b9 100644
--- a/tests/unit/out/refcount/operator_comparison_defaulted.rs
+++ b/tests/unit/out/refcount/operator_comparison_defaulted.rs
@@ -408,6 +408,7 @@ impl ByteRepr for Secondary {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -724,3 +725,4 @@ impl SecondaryImpl for Ptr<Secondary> {
         }) != std::cmp::Ordering::Less;
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_comparison_free.rs b/tests/unit/out/refcount/operator_comparison_free.rs
index 6b2384908..73e92aa4c 100644
--- a/tests/unit/out/refcount/operator_comparison_free.rs
+++ b/tests/unit/out/refcount/operator_comparison_free.rs
@@ -118,6 +118,7 @@ pub fn operator_lt_7(a: i32, b: Ptr<S>) -> bool {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -181,3 +182,4 @@ fn main_0() -> i32 {
     assert!(({ operator_lt_7(0, a.as_pointer(),) }));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_comparison_member.rs b/tests/unit/out/refcount/operator_comparison_member.rs
index b1bf82e86..ce29724c9 100644
--- a/tests/unit/out/refcount/operator_comparison_member.rs
+++ b/tests/unit/out/refcount/operator_comparison_member.rs
@@ -68,6 +68,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -141,3 +142,4 @@ impl SImpl for Ptr<S> {
         return ((*(*(*self).upgrade().deref()).v.borrow()) < (*o.borrow()));
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_comparison_mixed.rs b/tests/unit/out/refcount/operator_comparison_mixed.rs
index 1163f6a46..bd1115762 100644
--- a/tests/unit/out/refcount/operator_comparison_mixed.rs
+++ b/tests/unit/out/refcount/operator_comparison_mixed.rs
@@ -82,6 +82,7 @@ pub fn operator_lt_6(a: Ptr<S>, b: i32) -> bool {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -152,3 +153,4 @@ impl SImpl for Ptr<S> {
         };
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_comparison_noncopyable.rs b/tests/unit/out/refcount/operator_comparison_noncopyable.rs
index fd5f23ca6..476d99d8f 100644
--- a/tests/unit/out/refcount/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/refcount/operator_comparison_noncopyable.rs
@@ -99,6 +99,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -125,3 +126,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_compound_assignment_free.rs b/tests/unit/out/refcount/operator_compound_assignment_free.rs
index 74cb86ac4..4b2fb36bb 100644
--- a/tests/unit/out/refcount/operator_compound_assignment_free.rs
+++ b/tests/unit/out/refcount/operator_compound_assignment_free.rs
@@ -98,6 +98,7 @@ pub fn operator_shr_assign_9(a: Ptr<S>, n: i32) -> Ptr<S> {
     return (a).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -169,3 +170,4 @@ fn main_0() -> i32 {
     assert!(((*(*a.borrow()).v.borrow()) == 14_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_compound_assignment_member.rs b/tests/unit/out/refcount/operator_compound_assignment_member.rs
index 6c9e61f3d..56cd792b8 100644
--- a/tests/unit/out/refcount/operator_compound_assignment_member.rs
+++ b/tests/unit/out/refcount/operator_compound_assignment_member.rs
@@ -33,6 +33,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -168,3 +169,4 @@ impl SImpl for Ptr<S> {
         return (*self).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_less_than.rs b/tests/unit/out/refcount/operator_less_than.rs
index b2c303367..c35245a5c 100644
--- a/tests/unit/out/refcount/operator_less_than.rs
+++ b/tests/unit/out/refcount/operator_less_than.rs
@@ -107,6 +107,7 @@ impl ByteRepr for Pair {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -138,3 +139,4 @@ impl PairImpl for Ptr<Pair> {
         }));
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_logical_free.rs b/tests/unit/out/refcount/operator_logical_free.rs
index 9a4748234..d0d64ccfc 100644
--- a/tests/unit/out/refcount/operator_logical_free.rs
+++ b/tests/unit/out/refcount/operator_logical_free.rs
@@ -44,6 +44,7 @@ pub fn operator_or_2(a: Ptr<S>, b: Ptr<S>) -> bool {
         || ((*(*b.upgrade().deref()).v.borrow()) != 0);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -93,3 +94,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_logical_member.rs b/tests/unit/out/refcount/operator_logical_member.rs
index 314d6fc6c..a5c9df596 100644
--- a/tests/unit/out/refcount/operator_logical_member.rs
+++ b/tests/unit/out/refcount/operator_logical_member.rs
@@ -33,6 +33,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -78,3 +79,4 @@ impl SImpl for Ptr<S> {
             || ((*(*o.upgrade().deref()).v.borrow()) != 0);
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_member_pointer_free.rs b/tests/unit/out/refcount/operator_member_pointer_free.rs
index 0fb3dad5d..c683d21b8 100644
--- a/tests/unit/out/refcount/operator_member_pointer_free.rs
+++ b/tests/unit/out/refcount/operator_member_pointer_free.rs
@@ -79,6 +79,7 @@ pub fn operator_addr_1(s: Ptr<S>) -> Ptr<i32> {
     return (((*s.upgrade().deref()).data.as_pointer() as Ptr<i32>).offset(0));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -119,3 +120,4 @@ fn main_0() -> i32 {
     assert!(((*(*s.borrow()).data.borrow())[(0) as usize] == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_member_pointer_member.rs b/tests/unit/out/refcount/operator_member_pointer_member.rs
index 8d852312b..3c6674c97 100644
--- a/tests/unit/out/refcount/operator_member_pointer_member.rs
+++ b/tests/unit/out/refcount/operator_member_pointer_member.rs
@@ -101,6 +101,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -178,3 +179,6 @@ impl SImpl for Ptr<S> {
         return (((*(*self).upgrade().deref()).data.as_pointer() as Ptr<i32>).offset(0));
     }
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = table_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/operator_other_free.rs b/tests/unit/out/refcount/operator_other_free.rs
index 9cc3895e8..0d26549ee 100644
--- a/tests/unit/out/refcount/operator_other_free.rs
+++ b/tests/unit/out/refcount/operator_other_free.rs
@@ -41,6 +41,7 @@ pub fn operator_comma_0(a: Ptr<S>, b: Ptr<S>) -> S {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -76,3 +77,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_other_member.rs b/tests/unit/out/refcount/operator_other_member.rs
index 0395abaf1..fbd3e5c22 100644
--- a/tests/unit/out/refcount/operator_other_member.rs
+++ b/tests/unit/out/refcount/operator_other_member.rs
@@ -58,6 +58,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -128,3 +129,4 @@ impl SImpl for Ptr<S> {
         return ((*(*(*self).upgrade().deref()).v.borrow()) != 0);
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_overloads.rs b/tests/unit/out/refcount/operator_overloads.rs
index 4e2de1c54..42dd25eea 100644
--- a/tests/unit/out/refcount/operator_overloads.rs
+++ b/tests/unit/out/refcount/operator_overloads.rs
@@ -76,6 +76,7 @@ pub fn operator_eq_5(a: i64, b: Ptr<S>) -> i32 {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -176,3 +177,4 @@ impl SImpl for Ptr<S> {
         return (((*(*(*self).upgrade().deref()).v.borrow()) * (*o.borrow())) + 1);
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_qualifiers.rs b/tests/unit/out/refcount/operator_qualifiers.rs
index b0727eb64..569f3e0ec 100644
--- a/tests/unit/out/refcount/operator_qualifiers.rs
+++ b/tests/unit/out/refcount/operator_qualifiers.rs
@@ -33,6 +33,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -126,3 +127,4 @@ impl SImpl for Ptr<S> {
         return (((*(*(*self).upgrade().deref()).v.borrow()) + (*i.borrow())) + 100);
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_synonyms.rs b/tests/unit/out/refcount/operator_synonyms.rs
index 099ded8f4..53247d4d9 100644
--- a/tests/unit/out/refcount/operator_synonyms.rs
+++ b/tests/unit/out/refcount/operator_synonyms.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -30,3 +31,4 @@ fn main_0() -> i32 {
     assert!(((*a.borrow()) == 0_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_three_way.rs b/tests/unit/out/refcount/operator_three_way.rs
index 76b3f0962..0c0801d7b 100644
--- a/tests/unit/out/refcount/operator_three_way.rs
+++ b/tests/unit/out/refcount/operator_three_way.rs
@@ -59,6 +59,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -113,3 +114,4 @@ impl SImpl for Ptr<S> {
         };
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_traits.rs b/tests/unit/out/refcount/operator_traits.rs
index 4ac3a136e..da7812bf7 100644
--- a/tests/unit/out/refcount/operator_traits.rs
+++ b/tests/unit/out/refcount/operator_traits.rs
@@ -259,6 +259,7 @@ impl ByteRepr for Wrapped_int_ {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -527,3 +528,4 @@ impl LtImpl for Ptr<Lt> {
         };
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/overload_mangling.rs b/tests/unit/out/refcount/overload_mangling.rs
index c2e306b45..01647469c 100644
--- a/tests/unit/out/refcount/overload_mangling.rs
+++ b/tests/unit/out/refcount/overload_mangling.rs
@@ -59,6 +59,7 @@ impl ByteRepr for Box {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -125,3 +126,4 @@ impl SImpl for Ptr<S> {
         return (((*(*(*self).upgrade().deref()).base.borrow()) + (*x.borrow())) + (2 as i32));
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pair.rs b/tests/unit/out/refcount/pair.rs
index f64a154d2..bcefb3073 100644
--- a/tests/unit/out/refcount/pair.rs
+++ b/tests/unit/out/refcount/pair.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -30,3 +31,4 @@ fn main_0() -> i32 {
     assert!(((*(*p3.borrow()).1.borrow()) == 6));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pipe_io.rs b/tests/unit/out/refcount/pipe_io.rs
index 5f51cf011..3800ec5f7 100644
--- a/tests/unit/out/refcount/pipe_io.rs
+++ b/tests/unit/out/refcount/pipe_io.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -107,3 +108,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(0) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pod.rs b/tests/unit/out/refcount/pod.rs
index e1dcea718..8eff4edcb 100644
--- a/tests/unit/out/refcount/pod.rs
+++ b/tests/unit/out/refcount/pod.rs
@@ -46,6 +46,7 @@ pub fn PODIncrement_0(pod: Ptr<POD>) {
     (*(*pod.upgrade().deref()).x3.borrow_mut()) += 3;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -67,3 +68,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_add_assign.rs b/tests/unit/out/refcount/pointer_add_assign.rs
index 5e9646dfe..1b7008954 100644
--- a/tests/unit/out/refcount/pointer_add_assign.rs
+++ b/tests/unit/out/refcount/pointer_add_assign.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -53,3 +54,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_arithmetic.rs b/tests/unit/out/refcount/pointer_arithmetic.rs
index 5b244fdec..8e6e1f15d 100644
--- a/tests/unit/out/refcount/pointer_arithmetic.rs
+++ b/tests/unit/out/refcount/pointer_arithmetic.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -44,3 +45,4 @@ fn main_0() -> i32 {
     assert!(((*x.borrow()) == 4));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_array.rs b/tests/unit/out/refcount/pointer_array.rs
index 2fd7520f9..e5f4d78b6 100644
--- a/tests/unit/out/refcount/pointer_array.rs
+++ b/tests/unit/out/refcount/pointer_array.rs
@@ -54,6 +54,7 @@ pub fn IncrementAll_0(s: Ptr<StackArray>) {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -69,3 +70,4 @@ fn main_0() -> i32 {
     assert!(((*x.borrow()) == 3));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_call_offset.rs b/tests/unit/out/refcount/pointer_call_offset.rs
index 7f2dbdffc..52dc99a78 100644
--- a/tests/unit/out/refcount/pointer_call_offset.rs
+++ b/tests/unit/out/refcount/pointer_call_offset.rs
@@ -11,6 +11,7 @@ pub fn foo_0(p: Ptr<i32>) -> Ptr<i32> {
     return ((*p.borrow()).offset((5) as isize));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     assert!(((*out.borrow()) == 9));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_diff.rs b/tests/unit/out/refcount/pointer_diff.rs
index fa2ddccc9..bc4eaa2bf 100644
--- a/tests/unit/out/refcount/pointer_diff.rs
+++ b/tests/unit/out/refcount/pointer_diff.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     assert!((((*p1.borrow()).clone() - (*p0.borrow()).clone()) as i64 == 4_i64));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_eq.rs b/tests/unit/out/refcount/pointer_eq.rs
index 7c9666a4d..4259cb3f5 100644
--- a/tests/unit/out/refcount/pointer_eq.rs
+++ b/tests/unit/out/refcount/pointer_eq.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -62,3 +63,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_neq.rs b/tests/unit/out/refcount/pointer_neq.rs
index e2c854e33..a80f8d18f 100644
--- a/tests/unit/out/refcount/pointer_neq.rs
+++ b/tests/unit/out/refcount/pointer_neq.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -21,3 +22,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_offset.rs b/tests/unit/out/refcount/pointer_offset.rs
index 103d6e777..443452df2 100644
--- a/tests/unit/out/refcount/pointer_offset.rs
+++ b/tests/unit/out/refcount/pointer_offset.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -53,3 +54,4 @@ fn main_0() -> i32 {
     assert!(((*out.borrow()) == 51));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_printf.rs b/tests/unit/out/refcount/pointer_printf.rs
index 0c0be9cff..14388ca9a 100644
--- a/tests/unit/out/refcount/pointer_printf.rs
+++ b/tests/unit/out/refcount/pointer_printf.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     print!("{:?} {}", (*p.borrow()), ((*p.borrow()).read()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_to_boolean.rs b/tests/unit/out/refcount/pointer_to_boolean.rs
index 341bf00a6..8bd7733ff 100644
--- a/tests/unit/out/refcount/pointer_to_boolean.rs
+++ b/tests/unit/out/refcount/pointer_to_boolean.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     assert!(!(!(*x.borrow()).is_null()));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointer_usize_arith.rs b/tests/unit/out/refcount/pointer_usize_arith.rs
index 01ff7dc7e..b87e520dc 100644
--- a/tests/unit/out/refcount/pointer_usize_arith.rs
+++ b/tests/unit/out/refcount/pointer_usize_arith.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -114,3 +115,4 @@ fn main_0() -> i32 {
     assert!((((*back.borrow()).read()) == 17));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointers.rs b/tests/unit/out/refcount/pointers.rs
index a16dfc198..f81a5151f 100644
--- a/tests/unit/out/refcount/pointers.rs
+++ b/tests/unit/out/refcount/pointers.rs
@@ -48,6 +48,7 @@ pub fn Update_0(t: Ptr<Test>) -> Ptr<Test> {
     return (*t.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -95,3 +96,4 @@ impl TestImpl for Ptr<Test> {
         (*(*(*self).upgrade().deref()).x.borrow_mut()) = ((*x.borrow()) + (*y.borrow()));
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/poll.rs b/tests/unit/out/refcount/poll.rs
index f996dc137..a8918a46f 100644
--- a/tests/unit/out/refcount/poll.rs
+++ b/tests/unit/out/refcount/poll.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -129,3 +130,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(1) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/polymorphism.rs b/tests/unit/out/refcount/polymorphism.rs
index 6e2b6cf9d..ecceb0753 100644
--- a/tests/unit/out/refcount/polymorphism.rs
+++ b/tests/unit/out/refcount/polymorphism.rs
@@ -56,6 +56,7 @@ impl ByteRepr for Cat {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -82,3 +83,4 @@ impl CatImpl for Ptr<Cat> {
         return true;
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/printfs.rs b/tests/unit/out/refcount/printfs.rs
index 704eb21dc..2276ea056 100644
--- a/tests/unit/out/refcount/printfs.rs
+++ b/tests/unit/out/refcount/printfs.rs
@@ -20,6 +20,7 @@ pub fn fn2_1(v: Ptr<Vec<u8>>) -> Ptr<Vec<u8>> {
     return (v).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -57,3 +58,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/prvalue-as-lvalue.rs b/tests/unit/out/refcount/prvalue-as-lvalue.rs
index 260d7b718..ea3fd3645 100644
--- a/tests/unit/out/refcount/prvalue-as-lvalue.rs
+++ b/tests/unit/out/refcount/prvalue-as-lvalue.rs
@@ -10,6 +10,7 @@ pub fn foo_0(a: Ptr<i32>) -> Ptr<i32> {
     return (a).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!(((b.read()) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ptr2ptr.rs b/tests/unit/out/refcount/ptr2ptr.rs
index ceb5378b4..3b7da4388 100644
--- a/tests/unit/out/refcount/ptr2ptr.rs
+++ b/tests/unit/out/refcount/ptr2ptr.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -23,3 +24,4 @@ fn main_0() -> i32 {
     (*out.borrow_mut()) *= (*x.borrow());
     return (*out.borrow());
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ptr_cast_init.rs b/tests/unit/out/refcount/ptr_cast_init.rs
index 7e0042e44..3bad3d299 100644
--- a/tests/unit/out/refcount/ptr_cast_init.rs
+++ b/tests/unit/out/refcount/ptr_cast_init.rs
@@ -59,6 +59,7 @@ impl ByteRepr for view {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -101,3 +102,4 @@ fn main_0() -> i32 {
     assert!(((((*sel.borrow()).is_null()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ptr_to_incomplete_struct.rs b/tests/unit/out/refcount/ptr_to_incomplete_struct.rs
index 342a9937a..2db5a1134 100644
--- a/tests/unit/out/refcount/ptr_to_incomplete_struct.rs
+++ b/tests/unit/out/refcount/ptr_to_incomplete_struct.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs
index e547adace..9ca68f1e1 100644
--- a/tests/unit/out/refcount/push_emplace_back.rs
+++ b/tests/unit/out/refcount/push_emplace_back.rs
@@ -198,6 +198,7 @@ pub fn self_ref_push_6(comps: Ptr<Vec<Chunk>>) {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -336,3 +337,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pwd.rs b/tests/unit/out/refcount/pwd.rs
index 7cd84a262..86e497c1b 100644
--- a/tests/unit/out/refcount/pwd.rs
+++ b/tests/unit/out/refcount/pwd.rs
@@ -220,6 +220,7 @@ pub fn test_getpwuid_r_erange_3() {
     assert!(((((*result.borrow()).is_null()) as i32) != 0));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -229,3 +230,4 @@ fn main_0() -> i32 {
     ({ test_getpwuid_r_erange_3() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/qsort_bsearch.rs b/tests/unit/out/refcount/qsort_bsearch.rs
index d53ecb1d8..e0f9a3bb5 100644
--- a/tests/unit/out/refcount/qsort_bsearch.rs
+++ b/tests/unit/out/refcount/qsort_bsearch.rs
@@ -18,6 +18,7 @@ pub fn cmp_int_0(a: AnyPtr, b: AnyPtr) -> i32 {
     return ((((*x.borrow()) > (*y.borrow())) as i32) - (((*x.borrow()) < (*y.borrow())) as i32));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -125,3 +126,4 @@ fn main_0() -> i32 {
     assert!(((((*miss.borrow()).is_null()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/random.rs b/tests/unit/out/refcount/random.rs
index 3e857cbca..e9c711c8e 100644
--- a/tests/unit/out/refcount/random.rs
+++ b/tests/unit/out/refcount/random.rs
@@ -78,6 +78,7 @@ pub fn foo_1(x1: i32, x2: Ptr<i32>, x3: Ptr<i32>, p2: Ptr<Pair>, p3: Ptr<Pair>)
     let p3: Value<Ptr<Pair>> = Rc::new(RefCell::new(p3));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -322,3 +323,4 @@ impl PairImpl for Ptr<Pair> {
         return ((*(*self).upgrade().deref()).x.as_pointer());
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/rebind.rs b/tests/unit/out/refcount/rebind.rs
index 35edf0344..229b5d74d 100644
--- a/tests/unit/out/refcount/rebind.rs
+++ b/tests/unit/out/refcount/rebind.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!(((*x.borrow()) == 10));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/redundant_copy_in_conversion.rs b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
index 28c591b48..eb7420496 100644
--- a/tests/unit/out/refcount/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
@@ -16,6 +16,7 @@ pub fn sink_0(it: RefcountMapIter<i32, i32>) -> i32 {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -51,3 +52,4 @@ fn main_0() -> i32 {
     assert!(((*r.borrow()) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ref_calls.rs b/tests/unit/out/refcount/ref_calls.rs
index 34ce94dc4..d2404fe8b 100644
--- a/tests/unit/out/refcount/ref_calls.rs
+++ b/tests/unit/out/refcount/ref_calls.rs
@@ -13,6 +13,7 @@ pub fn foo_1(x: Ptr<i32>) -> Ptr<i32> {
     return (x).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -31,3 +32,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reference_wrapper.rs b/tests/unit/out/refcount/reference_wrapper.rs
index b04c05926..c0a3a25e7 100644
--- a/tests/unit/out/refcount/reference_wrapper.rs
+++ b/tests/unit/out/refcount/reference_wrapper.rs
@@ -47,6 +47,7 @@ pub fn read_1(ref_: Ptr<i32>) -> i32 {
     return (r.read());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -97,3 +98,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/references.rs b/tests/unit/out/refcount/references.rs
index ad31326eb..61764d3ae 100644
--- a/tests/unit/out/refcount/references.rs
+++ b/tests/unit/out/refcount/references.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     assert!(((*x.borrow()) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/references2.rs b/tests/unit/out/refcount/references2.rs
index d7b1e5272..277ff7aa0 100644
--- a/tests/unit/out/refcount/references2.rs
+++ b/tests/unit/out/refcount/references2.rs
@@ -11,6 +11,7 @@ pub fn change_0(p: Ptr<Option<Value<i32>>>) {
     ((p).clone() as Ptr<Option<Value<i32>>>).write((*q.borrow_mut()).take());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!(((*(*a.borrow()).as_ref().unwrap().borrow()) == 7));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/refs_as_args.rs b/tests/unit/out/refcount/refs_as_args.rs
index cf1416c08..1e2b439a8 100644
--- a/tests/unit/out/refcount/refs_as_args.rs
+++ b/tests/unit/out/refcount/refs_as_args.rs
@@ -43,6 +43,7 @@ pub fn more_refs_0(x1: i32, x2: i32, r1: Ptr<i32>, r2: Ptr<i32>) {
     r1.write(__rhs);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -52,3 +53,4 @@ fn main_0() -> i32 {
     assert!((((*x1.borrow()) + (*x2.borrow())) == 21));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast.rs b/tests/unit/out/refcount/reinterpret_cast.rs
index 6f3019872..7a07f2534 100644
--- a/tests/unit/out/refcount/reinterpret_cast.rs
+++ b/tests/unit/out/refcount/reinterpret_cast.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -25,3 +26,4 @@ fn main_0() -> i32 {
     assert!(((((*arr16.borrow()).offset((1) as isize).read()) as i32) == 1027));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_aliased.rs b/tests/unit/out/refcount/reinterpret_cast_aliased.rs
index 30bc28362..03b14219e 100644
--- a/tests/unit/out/refcount/reinterpret_cast_aliased.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_aliased.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -23,3 +24,4 @@ fn main_0() -> i32 {
     assert!(((*val.borrow()) == 18441921396093008810_u64));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_array_write.rs b/tests/unit/out/refcount/reinterpret_cast_array_write.rs
index dd0dbec7a..fc093a205 100644
--- a/tests/unit/out/refcount/reinterpret_cast_array_write.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_array_write.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -32,3 +33,4 @@ fn main_0() -> i32 {
     assert!((((*arr.borrow())[(3) as usize] as i32) == 4));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_chain.rs b/tests/unit/out/refcount/reinterpret_cast_chain.rs
index 4f8b446da..f444c9f06 100644
--- a/tests/unit/out/refcount/reinterpret_cast_chain.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_chain.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -32,3 +33,4 @@ fn main_0() -> i32 {
     assert!(((((*words.borrow()).offset((3) as isize).read()) as i32) == 65518));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_double.rs b/tests/unit/out/refcount/reinterpret_cast_double.rs
index d50ca3764..86ba3fb57 100644
--- a/tests/unit/out/refcount/reinterpret_cast_double.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_double.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -17,3 +18,4 @@ fn main_0() -> i32 {
     assert!(((*d.borrow()) > 3.14E+0) && ((*d.borrow()) < 3.15E+0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_empty_vec.rs b/tests/unit/out/refcount/reinterpret_cast_empty_vec.rs
index 50fa67ad2..7805b2765 100644
--- a/tests/unit/out/refcount/reinterpret_cast_empty_vec.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_empty_vec.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     ));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_float.rs b/tests/unit/out/refcount/reinterpret_cast_float.rs
index 9aa0c7396..d60ad03c5 100644
--- a/tests/unit/out/refcount/reinterpret_cast_float.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_float.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -17,3 +18,4 @@ fn main_0() -> i32 {
     assert!(((*f.borrow()) == 2.0E+0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_i16_u16.rs b/tests/unit/out/refcount/reinterpret_cast_i16_u16.rs
index 24ba1ba24..9ed541425 100644
--- a/tests/unit/out/refcount/reinterpret_cast_i16_u16.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_i16_u16.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -25,3 +26,4 @@ fn main_0() -> i32 {
     assert!((((*vals.borrow())[(0) as usize] as i32) == 42));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_identity.rs b/tests/unit/out/refcount/reinterpret_cast_identity.rs
index 1d5698d86..56ca47ef8 100644
--- a/tests/unit/out/refcount/reinterpret_cast_identity.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_identity.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -30,3 +31,4 @@ fn main_0() -> i32 {
     assert!((((*back2.borrow()).read()) == 42_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_iterate.rs b/tests/unit/out/refcount/reinterpret_cast_iterate.rs
index 8e14bd3f2..cd518ef9c 100644
--- a/tests/unit/out/refcount/reinterpret_cast_iterate.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_iterate.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -27,3 +28,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_large_array.rs b/tests/unit/out/refcount/reinterpret_cast_large_array.rs
index 29167abcd..acdb561a2 100644
--- a/tests/unit/out/refcount/reinterpret_cast_large_array.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_large_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     (*arr.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_new.rs b/tests/unit/out/refcount/reinterpret_cast_new.rs
index c02d0a611..58499340e 100644
--- a/tests/unit/out/refcount/reinterpret_cast_new.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_new.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -21,3 +22,4 @@ fn main_0() -> i32 {
     (*p.borrow()).delete();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_new_array.rs b/tests/unit/out/refcount/reinterpret_cast_new_array.rs
index 825f30884..28e70dc5e 100644
--- a/tests/unit/out/refcount/reinterpret_cast_new_array.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_new_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     (*arr.borrow()).delete_array();
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_oob_read.rs b/tests/unit/out/refcount/reinterpret_cast_oob_read.rs
index 9d8056914..816e5058c 100644
--- a/tests/unit/out/refcount/reinterpret_cast_oob_read.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_oob_read.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     &(*x.borrow_mut());
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_oob_write.rs b/tests/unit/out/refcount/reinterpret_cast_oob_write.rs
index d58992858..3b79e69d4 100644
--- a/tests/unit/out/refcount/reinterpret_cast_oob_write.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_oob_write.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -15,3 +16,4 @@ fn main_0() -> i32 {
     (*bytes.borrow()).offset((4) as isize).write(255_u8);
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_partial_overlap.rs b/tests/unit/out/refcount/reinterpret_cast_partial_overlap.rs
index 793bf41e7..5eeb059dd 100644
--- a/tests/unit/out/refcount/reinterpret_cast_partial_overlap.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_partial_overlap.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
     assert!(((*arr.borrow())[(1) as usize] == 134678186_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_roundtrip.rs b/tests/unit/out/refcount/reinterpret_cast_roundtrip.rs
index fcaf3c196..8ba41e6a6 100644
--- a/tests/unit/out/refcount/reinterpret_cast_roundtrip.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_roundtrip.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -25,3 +26,4 @@ fn main_0() -> i32 {
     assert!((((*as_int.borrow()).read()) == 67305985));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_same_type.rs b/tests/unit/out/refcount/reinterpret_cast_same_type.rs
index 71ef7e1fa..9d699ac86 100644
--- a/tests/unit/out/refcount/reinterpret_cast_same_type.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_same_type.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
     assert!((((*arr.borrow())[(2) as usize] as i32) == 99));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_signed.rs b/tests/unit/out/refcount/reinterpret_cast_signed.rs
index b8ebc6d07..d6e52c5c4 100644
--- a/tests/unit/out/refcount/reinterpret_cast_signed.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_signed.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     assert!(((((*quarters.borrow()).offset((3) as isize).read()) as i32) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_string.rs b/tests/unit/out/refcount/reinterpret_cast_string.rs
index 3dfd8521d..4e0a6fe98 100644
--- a/tests/unit/out/refcount/reinterpret_cast_string.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_string.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     assert!(((((*bytes.borrow()).offset((4) as isize).read()) as i32) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_struct.rs b/tests/unit/out/refcount/reinterpret_cast_struct.rs
index 66b368154..f0263990e 100644
--- a/tests/unit/out/refcount/reinterpret_cast_struct.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_struct.rs
@@ -37,6 +37,7 @@ impl ByteRepr for Point {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -50,3 +51,4 @@ fn main_0() -> i32 {
     assert!(((((*bytes.borrow()).offset((7) as isize).read()) as i32) == 8));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs b/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs
index c85ca78d9..0673e8555 100644
--- a/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_struct_to_struct.rs
@@ -67,6 +67,7 @@ impl ByteRepr for Pair {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -82,3 +83,4 @@ fn main_0() -> i32 {
     assert!(((*(*pt.borrow()).x.borrow()) == 42_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_u32_from_u8.rs b/tests/unit/out/refcount/reinterpret_cast_u32_from_u8.rs
index 4101a4e0a..c0b757606 100644
--- a/tests/unit/out/refcount/reinterpret_cast_u32_from_u8.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_u32_from_u8.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     assert!((((*dwords.borrow()).offset((1) as isize).read()) == 2427178479_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_undersize.rs b/tests/unit/out/refcount/reinterpret_cast_undersize.rs
index 39e443ba6..a0f505089 100644
--- a/tests/unit/out/refcount/reinterpret_cast_undersize.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_undersize.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -16,3 +17,4 @@ fn main_0() -> i32 {
     &(*val.borrow_mut());
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_vec_write.rs b/tests/unit/out/refcount/reinterpret_cast_vec_write.rs
index df915ca9b..7165f04bc 100644
--- a/tests/unit/out/refcount/reinterpret_cast_vec_write.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_vec_write.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     assert!((((vec_.as_pointer() as Ptr<u32>).offset(1_usize).read()) == 134678271_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reinterpret_cast_zero_init.rs b/tests/unit/out/refcount/reinterpret_cast_zero_init.rs
index c4811a12e..5d27a8cfb 100644
--- a/tests/unit/out/refcount/reinterpret_cast_zero_init.rs
+++ b/tests/unit/out/refcount/reinterpret_cast_zero_init.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!(((*val.borrow()) == 3735928559_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reserved_keywords.rs b/tests/unit/out/refcount/reserved_keywords.rs
index 9d7720b94..e8feeecec 100644
--- a/tests/unit/out/refcount/reserved_keywords.rs
+++ b/tests/unit/out/refcount/reserved_keywords.rs
@@ -263,6 +263,7 @@ pub fn foo_0(
     return 0;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -351,3 +352,4 @@ fn main_0() -> i32 {
         )
     });
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ret_rvalue_ref.rs b/tests/unit/out/refcount/ret_rvalue_ref.rs
index 1c587c3cd..fd0d71d8a 100644
--- a/tests/unit/out/refcount/ret_rvalue_ref.rs
+++ b/tests/unit/out/refcount/ret_rvalue_ref.rs
@@ -10,6 +10,7 @@ pub fn foo_0(v: Ptr<i32>) -> i32 {
     return (v.read());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/rule_of_five.rs b/tests/unit/out/refcount/rule_of_five.rs
index 64efc9467..93a164766 100644
--- a/tests/unit/out/refcount/rule_of_five.rs
+++ b/tests/unit/out/refcount/rule_of_five.rs
@@ -123,6 +123,7 @@ pub fn make_3(size: i32) -> Buffer {
     return Buffer::Buffer_pmutBuffer({ b.as_pointer() });
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -224,3 +225,8 @@ impl BufferImpl for Ptr<Buffer> {
         return (*self).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = alive_0.with(Value::clone);
+    let _ = copies_1.with(Value::clone);
+    let _ = moves_2.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/rule_of_three.rs b/tests/unit/out/refcount/rule_of_three.rs
index 982f72865..c1835f077 100644
--- a/tests/unit/out/refcount/rule_of_three.rs
+++ b/tests/unit/out/refcount/rule_of_three.rs
@@ -106,6 +106,7 @@ pub fn sum_2(b: Ptr<Buffer>) -> i32 {
     return (*s.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -186,3 +187,7 @@ impl BufferImpl for Ptr<Buffer> {
         return (*self).clone();
     }
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = alive_0.with(Value::clone);
+    let _ = copies_1.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/rvalue_ref_general.rs b/tests/unit/out/refcount/rvalue_ref_general.rs
index 4673c8a1b..7a4a42f02 100644
--- a/tests/unit/out/refcount/rvalue_ref_general.rs
+++ b/tests/unit/out/refcount/rvalue_ref_general.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -56,3 +57,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/rvalue_ref_global.rs b/tests/unit/out/refcount/rvalue_ref_global.rs
index ed7a77f86..baec2c70f 100644
--- a/tests/unit/out/refcount/rvalue_ref_global.rs
+++ b/tests/unit/out/refcount/rvalue_ref_global.rs
@@ -11,9 +11,13 @@ thread_local!(
     pub static g_0: Ptr<i32> = __tmp_0.with(Value::as_pointer);
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!(((g_0.with(Ptr::clone).read()) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = g_0.with(Ptr::clone);
+}
diff --git a/tests/unit/out/refcount/rvalue_ref_goto.rs b/tests/unit/out/refcount/rvalue_ref_goto.rs
index 88ef0ac86..ab483dd4f 100644
--- a/tests/unit/out/refcount/rvalue_ref_goto.rs
+++ b/tests/unit/out/refcount/rvalue_ref_goto.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     });
     panic!("ub: non-void function does not return a value")
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/rvalue_struct.rs b/tests/unit/out/refcount/rvalue_struct.rs
index 9ce77544c..e00a7c6cb 100644
--- a/tests/unit/out/refcount/rvalue_struct.rs
+++ b/tests/unit/out/refcount/rvalue_struct.rs
@@ -49,6 +49,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -58,3 +59,4 @@ fn main_0() -> i32 {
     assert!(((*(*s2.upgrade().deref()).b.borrow()) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs b/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs
index 2ef9141a7..7d9d73f41 100644
--- a/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs
+++ b/tests/unit/out/refcount/scalar_builtin_construct_destruct.rs
@@ -16,6 +16,7 @@ pub fn destroy_2(p: Ptr<i32>) {
     let p: Value<Ptr<i32>> = Rc::new(RefCell::new(p));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -31,3 +32,4 @@ fn main_0() -> i32 {
     assert!(((*x.borrow()) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/select.rs b/tests/unit/out/refcount/select.rs
index 161fbfcbc..b4f21d305 100644
--- a/tests/unit/out/refcount/select.rs
+++ b/tests/unit/out/refcount/select.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -324,3 +325,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(1) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/simple_function.rs b/tests/unit/out/refcount/simple_function.rs
index 0a565f824..f5a9267aa 100644
--- a/tests/unit/out/refcount/simple_function.rs
+++ b/tests/unit/out/refcount/simple_function.rs
@@ -10,6 +10,7 @@ pub fn foo_0() -> i32 {
     return 0;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     assert!((((*x.borrow()) + (*y.borrow())) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/simple_index.rs b/tests/unit/out/refcount/simple_index.rs
index c8a2e5071..fa06fcad0 100644
--- a/tests/unit/out/refcount/simple_index.rs
+++ b/tests/unit/out/refcount/simple_index.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/size_t_ssize_t.rs b/tests/unit/out/refcount/size_t_ssize_t.rs
index b9e140f73..cabc398b0 100644
--- a/tests/unit/out/refcount/size_t_ssize_t.rs
+++ b/tests/unit/out/refcount/size_t_ssize_t.rs
@@ -21,6 +21,7 @@ pub fn sub_signed_2(a: isize, b: isize) -> isize {
     return ((*a.borrow()) - (*b.borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -223,3 +224,4 @@ fn main_0() -> i32 {
     assert!(((((*n.borrow()).wrapping_rem(7_usize)) as i32) == 1));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/snprintf.rs b/tests/unit/out/refcount/snprintf.rs
index 70b92fcec..e2aecd64f 100644
--- a/tests/unit/out/refcount/snprintf.rs
+++ b/tests/unit/out/refcount/snprintf.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -429,3 +430,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/socket_listen.rs b/tests/unit/out/refcount/socket_listen.rs
index 1af600fa8..7b76aa6b2 100644
--- a/tests/unit/out/refcount/socket_listen.rs
+++ b/tests/unit/out/refcount/socket_listen.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -59,3 +60,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*s.borrow())) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/socket_open_close.rs b/tests/unit/out/refcount/socket_open_close.rs
index 7cb8a701d..ee647233e 100644
--- a/tests/unit/out/refcount/socket_open_close.rs
+++ b/tests/unit/out/refcount/socket_open_close.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*s.borrow())) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/socket_transparent_union.rs b/tests/unit/out/refcount/socket_transparent_union.rs
index 8ff1ea8c4..4a798bc73 100644
--- a/tests/unit/out/refcount/socket_transparent_union.rs
+++ b/tests/unit/out/refcount/socket_transparent_union.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -53,3 +54,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/socket_type_constants.rs b/tests/unit/out/refcount/socket_type_constants.rs
index 605f0ca03..f0783e7b5 100644
--- a/tests/unit/out/refcount/socket_type_constants.rs
+++ b/tests/unit/out/refcount/socket_type_constants.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     assert!((((libc::SOCK_DGRAM == 2) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/sockopt.rs b/tests/unit/out/refcount/sockopt.rs
index 1afb88faa..4ae831ea7 100644
--- a/tests/unit/out/refcount/sockopt.rs
+++ b/tests/unit/out/refcount/sockopt.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -92,3 +93,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*s.borrow())) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/sort.rs b/tests/unit/out/refcount/sort.rs
index 71368aec7..eb5bce489 100644
--- a/tests/unit/out/refcount/sort.rs
+++ b/tests/unit/out/refcount/sort.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -36,3 +37,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/split_binop_aliased_borrows.rs b/tests/unit/out/refcount/split_binop_aliased_borrows.rs
index 517116b90..8879da974 100644
--- a/tests/unit/out/refcount/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/refcount/split_binop_aliased_borrows.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -18,3 +19,4 @@ fn main_0() -> i32 {
     assert!((((v.as_pointer() as Ptr<i32>).offset(0_usize).read()) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stable_sort.rs b/tests/unit/out/refcount/stable_sort.rs
index 5da4a391d..161017e2b 100644
--- a/tests/unit/out/refcount/stable_sort.rs
+++ b/tests/unit/out/refcount/stable_sort.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     };
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/static_function_vars_same_name.rs b/tests/unit/out/refcount/static_function_vars_same_name.rs
index 6f10d84a2..752eab24a 100644
--- a/tests/unit/out/refcount/static_function_vars_same_name.rs
+++ b/tests/unit/out/refcount/static_function_vars_same_name.rs
@@ -19,6 +19,7 @@ pub fn b_2() -> i32 {
     return (*i_3.with(Value::clone).borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     assert!((({ b_2() }) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/static_local.rs b/tests/unit/out/refcount/static_local.rs
index e023daeee..395d3227b 100644
--- a/tests/unit/out/refcount/static_local.rs
+++ b/tests/unit/out/refcount/static_local.rs
@@ -27,9 +27,11 @@ pub fn foo_0() -> i32 {
         + (*static_i_1.with(Value::clone).borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((((({ foo_0() }) + ({ foo_0() })) + ({ foo_0() })) == 15));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/static_shadow.rs b/tests/unit/out/refcount/static_shadow.rs
index 9a4ee6ef6..6e1b0c603 100644
--- a/tests/unit/out/refcount/static_shadow.rs
+++ b/tests/unit/out/refcount/static_shadow.rs
@@ -21,6 +21,7 @@ pub fn read_global_3() -> i32 {
     return (*value_0.with(Value::clone).borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -29,3 +30,6 @@ fn main_0() -> i32 {
     assert!((((({ read_global_3() }) == 5) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = value_0.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/static_var_in_class.rs b/tests/unit/out/refcount/static_var_in_class.rs
index 5b163fa79..6fd82f819 100644
--- a/tests/unit/out/refcount/static_var_in_class.rs
+++ b/tests/unit/out/refcount/static_var_in_class.rs
@@ -49,6 +49,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -65,3 +66,7 @@ impl CImpl for Ptr<C> {
         return (*inner_const_0.with(Value::clone).borrow());
     }
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = inner_const_0.with(Value::clone);
+    let _ = inner_const_1.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/stdcopy.rs b/tests/unit/out/refcount/stdcopy.rs
index 9f4fabe23..ada9ec4e7 100644
--- a/tests/unit/out/refcount/stdcopy.rs
+++ b/tests/unit/out/refcount/stdcopy.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     };
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stdcopy_ostream.rs b/tests/unit/out/refcount/stdcopy_ostream.rs
index 408f521fa..e34142521 100644
--- a/tests/unit/out/refcount/stdcopy_ostream.rs
+++ b/tests/unit/out/refcount/stdcopy_ostream.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     };
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stdio.rs b/tests/unit/out/refcount/stdio.rs
index 33c19da58..a30dc3dcf 100644
--- a/tests/unit/out/refcount/stdio.rs
+++ b/tests/unit/out/refcount/stdio.rs
@@ -140,6 +140,7 @@ pub fn test_fileno_3() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -149,3 +150,4 @@ fn main_0() -> i32 {
     ({ test_fileno_3() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stdio_nofd.rs b/tests/unit/out/refcount/stdio_nofd.rs
index e459d55b7..0cdc09cf8 100644
--- a/tests/unit/out/refcount/stdio_nofd.rs
+++ b/tests/unit/out/refcount/stdio_nofd.rs
@@ -710,6 +710,7 @@ pub fn test_setvbuf_6() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -722,3 +723,4 @@ fn main_0() -> i32 {
     ({ test_setvbuf_6() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stdmin_fpoint.rs b/tests/unit/out/refcount/stdmin_fpoint.rs
index cb59ac83a..247654a03 100644
--- a/tests/unit/out/refcount/stdmin_fpoint.rs
+++ b/tests/unit/out/refcount/stdmin_fpoint.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     };
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stmt_expr.rs b/tests/unit/out/refcount/stmt_expr.rs
index c7a3bda53..58716aa06 100644
--- a/tests/unit/out/refcount/stmt_expr.rs
+++ b/tests/unit/out/refcount/stmt_expr.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -48,3 +49,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/strdup.rs b/tests/unit/out/refcount/strdup.rs
index 33c1f344e..d1e8e222d 100644
--- a/tests/unit/out/refcount/strdup.rs
+++ b/tests/unit/out/refcount/strdup.rs
@@ -31,6 +31,7 @@ impl ByteRepr for record {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -158,3 +159,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string.rs b/tests/unit/out/refcount/string.rs
index 02d72b7e6..a3055f1f1 100644
--- a/tests/unit/out/refcount/string.rs
+++ b/tests/unit/out/refcount/string.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -490,3 +491,4 @@ fn main_0() -> i32 {
     assert!(((*t4.borrow()).wrapping_add(((*s5.borrow()).len() - 1)) == 139_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string2.rs b/tests/unit/out/refcount/string2.rs
index d89e5ea08..d44276d44 100644
--- a/tests/unit/out/refcount/string2.rs
+++ b/tests/unit/out/refcount/string2.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -32,3 +33,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_escape.rs b/tests/unit/out/refcount/string_escape.rs
index 130fdce85..98f660a91 100644
--- a/tests/unit/out/refcount/string_escape.rs
+++ b/tests/unit/out/refcount/string_escape.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -71,3 +72,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_h.rs b/tests/unit/out/refcount/string_h.rs
index 232e6f233..1ed6344f8 100644
--- a/tests/unit/out/refcount/string_h.rs
+++ b/tests/unit/out/refcount/string_h.rs
@@ -967,6 +967,7 @@ pub fn test_strcasecmp_14() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -987,3 +988,4 @@ fn main_0() -> i32 {
     ({ test_strcasecmp_14() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literal_interior_null.rs b/tests/unit/out/refcount/string_literal_interior_null.rs
index 4df8ad389..33fcbda7f 100644
--- a/tests/unit/out/refcount/string_literal_interior_null.rs
+++ b/tests/unit/out/refcount/string_literal_interior_null.rs
@@ -22,6 +22,7 @@ thread_local!(
         Rc::new(RefCell::new(Ptr::from_string_literal(b"\x01\0")));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,6 @@ fn main_0() -> i32 {
     assert!(((*d.borrow()) == (('b' as u8) as i32)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = g_packet_1.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/string_literal_ptr_init.rs b/tests/unit/out/refcount/string_literal_ptr_init.rs
index c79e6a2b5..06a951122 100644
--- a/tests/unit/out/refcount/string_literal_ptr_init.rs
+++ b/tests/unit/out/refcount/string_literal_ptr_init.rs
@@ -65,6 +65,7 @@ thread_local!(
     ])));
 );
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -171,3 +172,6 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = table_1.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/string_literals.rs b/tests/unit/out/refcount/string_literals.rs
index d57498a6d..60a91e3e9 100644
--- a/tests/unit/out/refcount/string_literals.rs
+++ b/tests/unit/out/refcount/string_literals.rs
@@ -13,6 +13,7 @@ pub fn foo_const_1(str: Ptr<u8>) {
     let str: Value<Ptr<u8>> = Rc::new(RefCell::new(str));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,4 @@ fn main_0() -> i32 {
     ({ foo_const_1((inited_through_init_list.as_pointer() as Ptr<u8>)) });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literals_c.rs b/tests/unit/out/refcount/string_literals_c.rs
index bdac6f4e7..799970b24 100644
--- a/tests/unit/out/refcount/string_literals_c.rs
+++ b/tests/unit/out/refcount/string_literals_c.rs
@@ -13,6 +13,7 @@ pub fn foo_const_1(str: Ptr<u8>) {
     let str: Value<Ptr<u8>> = Rc::new(RefCell::new(str));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -55,3 +56,4 @@ fn main_0() -> i32 {
     ({ foo_const_1((inited_through_init_list.as_pointer() as Ptr<u8>)) });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literals_concat.rs b/tests/unit/out/refcount/string_literals_concat.rs
index 07056ef6e..4c19974d0 100644
--- a/tests/unit/out/refcount/string_literals_concat.rs
+++ b/tests/unit/out/refcount/string_literals_concat.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literals_concat_c.rs b/tests/unit/out/refcount/string_literals_concat_c.rs
index 5fa3aa273..9eb38e846 100644
--- a/tests/unit/out/refcount/string_literals_concat_c.rs
+++ b/tests/unit/out/refcount/string_literals_concat_c.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -44,3 +45,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literals_return.rs b/tests/unit/out/refcount/string_literals_return.rs
index 8b535c143..feabaa41a 100644
--- a/tests/unit/out/refcount/string_literals_return.rs
+++ b/tests/unit/out/refcount/string_literals_return.rs
@@ -20,6 +20,7 @@ pub fn get_branch_2(x: i32) -> Ptr<u8> {
     return Ptr::from_string_literal(b"non-positive");
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -39,3 +40,4 @@ fn main_0() -> i32 {
     assert!(((((*d.borrow()).offset((12) as isize).read()) as i32) == (('\0' as u8) as i32)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literals_return_c.rs b/tests/unit/out/refcount/string_literals_return_c.rs
index b3f1ad6de..22a10fff6 100644
--- a/tests/unit/out/refcount/string_literals_return_c.rs
+++ b/tests/unit/out/refcount/string_literals_return_c.rs
@@ -20,6 +20,7 @@ pub fn get_branch_2(x: i32) -> Ptr<u8> {
     return Ptr::from_string_literal(b"non-positive");
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -49,3 +50,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literals_sized.rs b/tests/unit/out/refcount/string_literals_sized.rs
index 1c1d67dfc..ed8d36372 100644
--- a/tests/unit/out/refcount/string_literals_sized.rs
+++ b/tests/unit/out/refcount/string_literals_sized.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     assert!(((::std::mem::size_of::<[u8; 16]>() as usize).wrapping_sub(1_usize) == 15_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_literals_sized_c.rs b/tests/unit/out/refcount/string_literals_sized_c.rs
index 296e8ef84..18623cceb 100644
--- a/tests/unit/out/refcount/string_literals_sized_c.rs
+++ b/tests/unit/out/refcount/string_literals_sized_c.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/strlen.rs b/tests/unit/out/refcount/strlen.rs
index 0d9667082..eafd74f17 100644
--- a/tests/unit/out/refcount/strlen.rs
+++ b/tests/unit/out/refcount/strlen.rs
@@ -15,6 +15,7 @@ pub fn strlen_0(ptr: Ptr<u8>) -> u32 {
     return (*count.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -29,3 +30,4 @@ fn main_0() -> i32 {
     assert!((({ strlen_0(((string.as_pointer() as Ptr<u8>).offset(0)),) }) == 5_u32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/strlen_diff.rs b/tests/unit/out/refcount/strlen_diff.rs
index db9104af9..106bdb078 100644
--- a/tests/unit/out/refcount/strlen_diff.rs
+++ b/tests/unit/out/refcount/strlen_diff.rs
@@ -15,6 +15,7 @@ pub fn strlen_0(s: Ptr<u8>) -> usize {
     return ((((*s.borrow()).clone() - (*begin.borrow()).clone()) as i64) as usize);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -30,3 +31,4 @@ fn main_0() -> i32 {
     assert!((({ strlen_0(((s.as_pointer() as Ptr<u8>).offset(0)),) }) == 6_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/strlen_rec.rs b/tests/unit/out/refcount/strlen_rec.rs
index f95b9643d..d6e1763ce 100644
--- a/tests/unit/out/refcount/strlen_rec.rs
+++ b/tests/unit/out/refcount/strlen_rec.rs
@@ -16,6 +16,7 @@ pub fn strlen_0(s: Ptr<u8>, n: i32) -> i32 {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     assert!((({ strlen_0(((s.as_pointer() as Ptr<u8>).offset(0)), 0,) }) == 3));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/struct_ctor.rs b/tests/unit/out/refcount/struct_ctor.rs
index a9d9c5c3a..586e10403 100644
--- a/tests/unit/out/refcount/struct_ctor.rs
+++ b/tests/unit/out/refcount/struct_ctor.rs
@@ -54,6 +54,7 @@ pub fn foo_0(x: Ptr<i32>) -> Ptr<i32> {
     return (x).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -79,3 +80,4 @@ impl StructWithCtorImpl for Ptr<StructWithCtor> {
         return (*(*self).upgrade().deref()).x2_.as_pointer();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/struct_default_ctor.rs b/tests/unit/out/refcount/struct_default_ctor.rs
index d87a731e4..6ab4f46b2 100644
--- a/tests/unit/out/refcount/struct_default_ctor.rs
+++ b/tests/unit/out/refcount/struct_default_ctor.rs
@@ -52,6 +52,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -60,3 +61,4 @@ fn main_0() -> i32 {
     assert!((((*(*s.borrow()).b.borrow()) as i32) == (true as i32)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/struct_ptr.rs b/tests/unit/out/refcount/struct_ptr.rs
index 0336f8f78..799554b36 100644
--- a/tests/unit/out/refcount/struct_ptr.rs
+++ b/tests/unit/out/refcount/struct_ptr.rs
@@ -33,6 +33,7 @@ impl ByteRepr for XX {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -54,3 +55,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/swap.rs b/tests/unit/out/refcount/swap.rs
index 0e5384e3d..7e762c1eb 100644
--- a/tests/unit/out/refcount/swap.rs
+++ b/tests/unit/out/refcount/swap.rs
@@ -27,6 +27,7 @@ pub fn swap_by_ref_2(a: Ptr<i32>, b: Ptr<i32>) {
     b.write(__rhs);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,4 @@ fn main_0() -> i32 {
     assert!(((*c.borrow()) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/swap_extended.rs b/tests/unit/out/refcount/swap_extended.rs
index 8b6469fe1..ec589462b 100644
--- a/tests/unit/out/refcount/swap_extended.rs
+++ b/tests/unit/out/refcount/swap_extended.rs
@@ -27,6 +27,7 @@ pub fn swap_by_ref_2(a: Ptr<i32>, b: Ptr<i32>) {
     b.write(__rhs);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -82,3 +83,4 @@ fn main_0() -> i32 {
     assert!(((*c.borrow()) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_basic.rs b/tests/unit/out/refcount/switch_basic.rs
index 25b60600a..ffd205e93 100644
--- a/tests/unit/out/refcount/switch_basic.rs
+++ b/tests/unit/out/refcount/switch_basic.rs
@@ -34,6 +34,7 @@ pub fn basic_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,4 @@ fn main_0() -> i32 {
     assert!((({ basic_0(99,) }) == 40));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs b/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs
index e13f444e3..3de6b123a 100644
--- a/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs
+++ b/tests/unit/out/refcount/switch_borrow_in_condition_and_in_body.rs
@@ -17,6 +17,7 @@ pub fn borrow_in_condition_and_in_body_0(x: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     assert!((({ borrow_in_condition_and_in_body_0(1,) }) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_case_then_default.rs b/tests/unit/out/refcount/switch_case_then_default.rs
index ae6b216a9..a1cdf1699 100644
--- a/tests/unit/out/refcount/switch_case_then_default.rs
+++ b/tests/unit/out/refcount/switch_case_then_default.rs
@@ -25,6 +25,7 @@ pub fn case_then_default_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     assert!((({ case_then_default_0(99,) }) == 10));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_cases_and_default_stacked.rs b/tests/unit/out/refcount/switch_cases_and_default_stacked.rs
index 2f11539a4..6ad7b207c 100644
--- a/tests/unit/out/refcount/switch_cases_and_default_stacked.rs
+++ b/tests/unit/out/refcount/switch_cases_and_default_stacked.rs
@@ -25,6 +25,7 @@ pub fn cases_and_default_stacked_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     assert!((({ cases_and_default_stacked_0(99,) }) == 42));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_char.rs b/tests/unit/out/refcount/switch_char.rs
index 07c03e3b4..a6f6dd257 100644
--- a/tests/unit/out/refcount/switch_char.rs
+++ b/tests/unit/out/refcount/switch_char.rs
@@ -35,6 +35,7 @@ pub const Color_kRed: Color = 0;
 pub const Color_kGreen: Color = 1;
 pub const Color_kBlue: Color = 2;
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -45,3 +46,4 @@ fn main_0() -> i32 {
     assert!((({ switch_char_0(('z' as u8),) }) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_complex_cond.rs b/tests/unit/out/refcount/switch_complex_cond.rs
index c5143e463..61797a702 100644
--- a/tests/unit/out/refcount/switch_complex_cond.rs
+++ b/tests/unit/out/refcount/switch_complex_cond.rs
@@ -32,6 +32,7 @@ pub fn switch_complex_cond_0(p: Ptr<i32>, bias: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,4 @@ fn main_0() -> i32 {
     assert!((({ switch_complex_cond_0((p_val.as_pointer()), 99,) }) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_compound_case_body.rs b/tests/unit/out/refcount/switch_compound_case_body.rs
index c4a17f1ce..356fe8004 100644
--- a/tests/unit/out/refcount/switch_compound_case_body.rs
+++ b/tests/unit/out/refcount/switch_compound_case_body.rs
@@ -32,6 +32,7 @@ pub fn compound_case_body_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!((({ compound_case_body_0(9,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_continue_inside_switch.rs b/tests/unit/out/refcount/switch_continue_inside_switch.rs
index 068f9658f..d70769cec 100644
--- a/tests/unit/out/refcount/switch_continue_inside_switch.rs
+++ b/tests/unit/out/refcount/switch_continue_inside_switch.rs
@@ -30,9 +30,11 @@ pub fn continue_inside_switch_0(n: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ continue_inside_switch_0(6,) }) == (((1 + 3) + 5) + (3 * 1000))));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_default_first.rs b/tests/unit/out/refcount/switch_default_first.rs
index 57f0ab01e..d2b19c543 100644
--- a/tests/unit/out/refcount/switch_default_first.rs
+++ b/tests/unit/out/refcount/switch_default_first.rs
@@ -29,6 +29,7 @@ pub fn default_first_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -36,3 +37,4 @@ fn main_0() -> i32 {
     assert!((({ default_first_0(99,) }) == 7));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_default_middle.rs b/tests/unit/out/refcount/switch_default_middle.rs
index 48aee8b7d..f99f280f4 100644
--- a/tests/unit/out/refcount/switch_default_middle.rs
+++ b/tests/unit/out/refcount/switch_default_middle.rs
@@ -29,6 +29,7 @@ pub fn default_middle_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -37,3 +38,4 @@ fn main_0() -> i32 {
     assert!((({ default_middle_0(99,) }) == 99));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_default_then_case.rs b/tests/unit/out/refcount/switch_default_then_case.rs
index 1eb6cb21c..2e01f0b8e 100644
--- a/tests/unit/out/refcount/switch_default_then_case.rs
+++ b/tests/unit/out/refcount/switch_default_then_case.rs
@@ -29,6 +29,7 @@ pub fn default_then_case_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -38,3 +39,4 @@ fn main_0() -> i32 {
     assert!((({ default_then_case_0(99,) }) == 77));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_empty_case_with_break.rs b/tests/unit/out/refcount/switch_empty_case_with_break.rs
index a3783ef0a..2a8002af7 100644
--- a/tests/unit/out/refcount/switch_empty_case_with_break.rs
+++ b/tests/unit/out/refcount/switch_empty_case_with_break.rs
@@ -28,6 +28,7 @@ pub fn empty_case_with_break_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -36,3 +37,4 @@ fn main_0() -> i32 {
     assert!((({ empty_case_with_break_0(9,) }) == 9));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_empty_switch.rs b/tests/unit/out/refcount/switch_empty_switch.rs
index 109d2542f..30c3794f8 100644
--- a/tests/unit/out/refcount/switch_empty_switch.rs
+++ b/tests/unit/out/refcount/switch_empty_switch.rs
@@ -17,9 +17,11 @@ pub fn empty_switch_0(x: i32) -> i32 {
     return (*x.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ empty_switch_0(5,) }) == 5));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_enum.rs b/tests/unit/out/refcount/switch_enum.rs
index b89cf1cb0..dc317d9bf 100644
--- a/tests/unit/out/refcount/switch_enum.rs
+++ b/tests/unit/out/refcount/switch_enum.rs
@@ -30,6 +30,7 @@ pub fn switch_enum_0(c: Color) -> i32 {
     return -1_i32;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -38,3 +39,4 @@ fn main_0() -> i32 {
     assert!((({ switch_enum_0(Color_kBlue,) }) == 30));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_fallthrough_chain.rs b/tests/unit/out/refcount/switch_fallthrough_chain.rs
index fee2cd2d2..cad7c3de0 100644
--- a/tests/unit/out/refcount/switch_fallthrough_chain.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_chain.rs
@@ -31,6 +31,7 @@ pub fn fallthrough_chain_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     assert!((({ fallthrough_chain_0(99,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_fallthrough_default.rs b/tests/unit/out/refcount/switch_fallthrough_default.rs
index 9e819b00d..b438f714a 100644
--- a/tests/unit/out/refcount/switch_fallthrough_default.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_default.rs
@@ -25,6 +25,7 @@ pub fn fallthrough_default_0(x: i32, flag: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     assert!((({ fallthrough_default_0(99, 0,) }) == 42));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_fallthrough_into_block.rs b/tests/unit/out/refcount/switch_fallthrough_into_block.rs
index 86095eb06..5359cb442 100644
--- a/tests/unit/out/refcount/switch_fallthrough_into_block.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_into_block.rs
@@ -28,6 +28,7 @@ pub fn fallthrough_into_block_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -36,3 +37,4 @@ fn main_0() -> i32 {
     assert!((({ fallthrough_into_block_0(99,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_fallthrough_one.rs b/tests/unit/out/refcount/switch_fallthrough_one.rs
index b4fe92e92..cd7f9620b 100644
--- a/tests/unit/out/refcount/switch_fallthrough_one.rs
+++ b/tests/unit/out/refcount/switch_fallthrough_one.rs
@@ -25,6 +25,7 @@ pub fn fallthrough_one_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     assert!((({ fallthrough_one_0(99,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_for_in_switch_break.rs b/tests/unit/out/refcount/switch_for_in_switch_break.rs
index e255e5893..5c7f2533a 100644
--- a/tests/unit/out/refcount/switch_for_in_switch_break.rs
+++ b/tests/unit/out/refcount/switch_for_in_switch_break.rs
@@ -33,6 +33,7 @@ pub fn for_in_switch_break_0(n: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!((({ for_in_switch_break_0(99,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_for_in_switch_continue.rs b/tests/unit/out/refcount/switch_for_in_switch_continue.rs
index b436be236..e347f746f 100644
--- a/tests/unit/out/refcount/switch_for_in_switch_continue.rs
+++ b/tests/unit/out/refcount/switch_for_in_switch_continue.rs
@@ -33,6 +33,7 @@ pub fn for_in_switch_continue_0(n: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!((({ for_in_switch_continue_0(99,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_for_switch_for_break.rs b/tests/unit/out/refcount/switch_for_switch_for_break.rs
index 87ad0ab02..45262cede 100644
--- a/tests/unit/out/refcount/switch_for_switch_for_break.rs
+++ b/tests/unit/out/refcount/switch_for_switch_for_break.rs
@@ -37,9 +37,11 @@ pub fn for_switch_for_break_0(n: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ for_switch_for_break_0(3,) }) == 122));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_in_dowhile.rs b/tests/unit/out/refcount/switch_in_dowhile.rs
index fb0c62d2f..80e9576ab 100644
--- a/tests/unit/out/refcount/switch_in_dowhile.rs
+++ b/tests/unit/out/refcount/switch_in_dowhile.rs
@@ -35,6 +35,7 @@ pub fn switch_in_dowhile_0(n: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,4 @@ fn main_0() -> i32 {
     assert!((({ switch_in_dowhile_0(3,) }) == ((1 + 10) + 100)));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_in_loop.rs b/tests/unit/out/refcount/switch_in_loop.rs
index 1847fa6c7..cdb395cf2 100644
--- a/tests/unit/out/refcount/switch_in_loop.rs
+++ b/tests/unit/out/refcount/switch_in_loop.rs
@@ -34,9 +34,11 @@ pub fn switch_in_loop_0(n: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ switch_in_loop_0(6,) }) == 72));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_mixed_literal_cases.rs b/tests/unit/out/refcount/switch_mixed_literal_cases.rs
index 9d8346dfd..dc5f4a783 100644
--- a/tests/unit/out/refcount/switch_mixed_literal_cases.rs
+++ b/tests/unit/out/refcount/switch_mixed_literal_cases.rs
@@ -31,6 +31,7 @@ pub fn mixed_literal_cases_0(x: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     assert!((({ mixed_literal_cases_0(7,) }) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_mixed_return_break.rs b/tests/unit/out/refcount/switch_mixed_return_break.rs
index d05621857..8ae94bb9f 100644
--- a/tests/unit/out/refcount/switch_mixed_return_break.rs
+++ b/tests/unit/out/refcount/switch_mixed_return_break.rs
@@ -31,6 +31,7 @@ pub fn mixed_return_break_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!((({ mixed_return_break_0(99,) }) == 99));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_nested.rs b/tests/unit/out/refcount/switch_nested.rs
index 959be2d91..4ed7d984b 100644
--- a/tests/unit/out/refcount/switch_nested.rs
+++ b/tests/unit/out/refcount/switch_nested.rs
@@ -47,6 +47,7 @@ pub fn nested_0(a: i32, b: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -56,3 +57,4 @@ fn main_0() -> i32 {
     assert!((({ nested_0(3, 3,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_no_default.rs b/tests/unit/out/refcount/switch_no_default.rs
index a4551fb43..be1d29642 100644
--- a/tests/unit/out/refcount/switch_no_default.rs
+++ b/tests/unit/out/refcount/switch_no_default.rs
@@ -26,6 +26,7 @@ pub fn no_default_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     assert!((({ no_default_0(42,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_on_assignment.rs b/tests/unit/out/refcount/switch_on_assignment.rs
index 96ebd4b2b..3d138e10d 100644
--- a/tests/unit/out/refcount/switch_on_assignment.rs
+++ b/tests/unit/out/refcount/switch_on_assignment.rs
@@ -33,6 +33,7 @@ pub fn switch_on_assignment_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     assert!((({ switch_on_assignment_0(9,) }) == 10));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_on_call.rs b/tests/unit/out/refcount/switch_on_call.rs
index 5fb88e4ce..d43a8794c 100644
--- a/tests/unit/out/refcount/switch_on_call.rs
+++ b/tests/unit/out/refcount/switch_on_call.rs
@@ -32,6 +32,7 @@ pub fn switch_on_call_1(x: i32) -> i32 {
     panic!("ub: non-void function does not return a value")
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     assert!((({ switch_on_call_1(99,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_only_default.rs b/tests/unit/out/refcount/switch_only_default.rs
index e2a36c861..46772a7f7 100644
--- a/tests/unit/out/refcount/switch_only_default.rs
+++ b/tests/unit/out/refcount/switch_only_default.rs
@@ -21,9 +21,11 @@ pub fn only_default_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
     assert!((({ only_default_0(1,) }) == 42));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_stacked.rs b/tests/unit/out/refcount/switch_stacked.rs
index b3f87d6a2..aae336a35 100644
--- a/tests/unit/out/refcount/switch_stacked.rs
+++ b/tests/unit/out/refcount/switch_stacked.rs
@@ -29,6 +29,7 @@ pub fn stacked_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -38,3 +39,4 @@ fn main_0() -> i32 {
     assert!((({ stacked_0(9,) }) == 300));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_stacked_block.rs b/tests/unit/out/refcount/switch_stacked_block.rs
index 18acfad40..c50d97bcf 100644
--- a/tests/unit/out/refcount/switch_stacked_block.rs
+++ b/tests/unit/out/refcount/switch_stacked_block.rs
@@ -26,6 +26,7 @@ pub fn stacked_block_0(x: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     assert!((({ stacked_block_0(9,) }) == 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs b/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs
index e0aa3f15f..00646f7dc 100644
--- a/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs
+++ b/tests/unit/out/refcount/switch_stacked_with_inner_fallthrough.rs
@@ -25,6 +25,7 @@ pub fn stacked_with_inner_fallthrough_0(x: i32, flag: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     assert!((({ stacked_with_inner_fallthrough_0(99, 0,) }) == 999));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/switch_while_in_switch_break.rs b/tests/unit/out/refcount/switch_while_in_switch_break.rs
index 5f2184b29..6374983cd 100644
--- a/tests/unit/out/refcount/switch_while_in_switch_break.rs
+++ b/tests/unit/out/refcount/switch_while_in_switch_break.rs
@@ -33,6 +33,7 @@ pub fn while_in_switch_break_0(n: i32) -> i32 {
     return (*r.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!((({ while_in_switch_break_0(99,) }) == -1_i32));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/sys_stat.rs b/tests/unit/out/refcount/sys_stat.rs
index 6ca8fe0c0..059caa119 100644
--- a/tests/unit/out/refcount/sys_stat.rs
+++ b/tests/unit/out/refcount/sys_stat.rs
@@ -119,6 +119,7 @@ pub fn test_fstat_1() {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -126,3 +127,4 @@ fn main_0() -> i32 {
     ({ test_fstat_1() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/sys_time.rs b/tests/unit/out/refcount/sys_time.rs
index a26480fb0..919bfa430 100644
--- a/tests/unit/out/refcount/sys_time.rs
+++ b/tests/unit/out/refcount/sys_time.rs
@@ -298,6 +298,7 @@ pub fn test_strftime_5() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -307,3 +308,4 @@ fn main_0() -> i32 {
     ({ test_strftime_5() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/tag_vs_identifier_collision.rs b/tests/unit/out/refcount/tag_vs_identifier_collision.rs
index 2905b4b63..74eea3b77 100644
--- a/tests/unit/out/refcount/tag_vs_identifier_collision.rs
+++ b/tests/unit/out/refcount/tag_vs_identifier_collision.rs
@@ -223,6 +223,7 @@ pub fn is_active_0(w: Ptr<widget>) -> i32 {
         == ((widget_enum_MODE_ACTIVE as i32) as u32)) as i32);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -260,3 +261,4 @@ fn main_0() -> i32 {
     assert!(((((*(*w.borrow()).id.borrow()) == 7) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/template_pack.rs b/tests/unit/out/refcount/template_pack.rs
index ce7a2f34b..c12f4c0f8 100644
--- a/tests/unit/out/refcount/template_pack.rs
+++ b/tests/unit/out/refcount/template_pack.rs
@@ -58,6 +58,7 @@ pub fn sizeof_pack_9(args_0: i32, args_1: i32, args_2: i32, args_3: i32) -> i32
     return (4 as i32);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -72,3 +73,4 @@ fn main_0() -> i32 {
     assert!((({ sizeof_pack_9(1, 2, 3, 4,) }) == 4));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/templates.rs b/tests/unit/out/refcount/templates.rs
index 8183d5edc..8c662110d 100644
--- a/tests/unit/out/refcount/templates.rs
+++ b/tests/unit/out/refcount/templates.rs
@@ -45,6 +45,7 @@ pub fn func_5(x1: f64, x2: i32, x3: f64) -> i32 {
     return ((((*x1.borrow()) + ((*x2.borrow()) as f64)) + (*x3.borrow())) as i32);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -60,3 +61,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/termios.rs b/tests/unit/out/refcount/termios.rs
index edf6a8a57..e3bb7ee4a 100644
--- a/tests/unit/out/refcount/termios.rs
+++ b/tests/unit/out/refcount/termios.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -82,3 +83,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/this.rs b/tests/unit/out/refcount/this.rs
index a697f4c59..972b68994 100644
--- a/tests/unit/out/refcount/this.rs
+++ b/tests/unit/out/refcount/this.rs
@@ -117,6 +117,7 @@ impl ByteRepr for D {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -283,3 +284,4 @@ impl SImpl for Ptr<S> {
         return true;
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/typedef-anon-struct.rs b/tests/unit/out/refcount/typedef-anon-struct.rs
index 00fcdf5bb..8f5f1ce8d 100644
--- a/tests/unit/out/refcount/typedef-anon-struct.rs
+++ b/tests/unit/out/refcount/typedef-anon-struct.rs
@@ -63,6 +63,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -95,3 +96,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/types.rs b/tests/unit/out/refcount/types.rs
index ac07e3f27..bc5a9226e 100644
--- a/tests/unit/out/refcount/types.rs
+++ b/tests/unit/out/refcount/types.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -48,3 +49,4 @@ fn main_0() -> i32 {
     assert!((<AnyPtr>::default()).is_null());
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unary.rs b/tests/unit/out/refcount/unary.rs
index b259a9af0..60558f7ac 100644
--- a/tests/unit/out/refcount/unary.rs
+++ b/tests/unit/out/refcount/unary.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     assert!(((((*out.borrow_mut()).postfix_inc() + (*x2.borrow())) + (*x3.borrow())) == 19));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unary_expr_or_type_trait.rs b/tests/unit/out/refcount/unary_expr_or_type_trait.rs
index 1183a0e38..cf01eccd2 100644
--- a/tests/unit/out/refcount/unary_expr_or_type_trait.rs
+++ b/tests/unit/out/refcount/unary_expr_or_type_trait.rs
@@ -45,6 +45,7 @@ pub fn pack_size_1(args_0: i32, args_1: f64) -> u64 {
     return ((2 as usize).wrapping_add((2 as usize)) as u64);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -69,3 +70,4 @@ fn main_0() -> i32 {
     assert!((({ pack_size_1(1, 2.0E+0,) }) == 4_u64));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unconst.rs b/tests/unit/out/refcount/unconst.rs
index 8d34694b0..efbf9a80c 100644
--- a/tests/unit/out/refcount/unconst.rs
+++ b/tests/unit/out/refcount/unconst.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -22,3 +23,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_addrof_external.rs b/tests/unit/out/refcount/union_addrof_external.rs
index 15928f01a..ec0d5ec70 100644
--- a/tests/unit/out/refcount/union_addrof_external.rs
+++ b/tests/unit/out/refcount/union_addrof_external.rs
@@ -161,6 +161,7 @@ pub fn fill_1(out: AnyPtr, cap: usize) {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -223,3 +224,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_basic.rs b/tests/unit/out/refcount/union_basic.rs
index a9bd9e739..6a068b4ec 100644
--- a/tests/unit/out/refcount/union_basic.rs
+++ b/tests/unit/out/refcount/union_basic.rs
@@ -45,6 +45,7 @@ impl ByteRepr for basic {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -55,3 +56,4 @@ fn main_0() -> i32 {
     assert!((((*u.borrow()).f().read()) == 3.140000105E+0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_cross_arm_cast.rs b/tests/unit/out/refcount/union_cross_arm_cast.rs
index 70fa8176b..fc8f89822 100644
--- a/tests/unit/out/refcount/union_cross_arm_cast.rs
+++ b/tests/unit/out/refcount/union_cross_arm_cast.rs
@@ -167,6 +167,7 @@ impl ByteRepr for Container {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -224,3 +225,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_field_alignment.rs b/tests/unit/out/refcount/union_field_alignment.rs
index 54e96ad90..78f6a0af3 100644
--- a/tests/unit/out/refcount/union_field_alignment.rs
+++ b/tests/unit/out/refcount/union_field_alignment.rs
@@ -73,6 +73,7 @@ impl ByteRepr for node {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -90,3 +91,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_flex_array_member.rs b/tests/unit/out/refcount/union_flex_array_member.rs
index 6bf1107e4..cd217169b 100644
--- a/tests/unit/out/refcount/union_flex_array_member.rs
+++ b/tests/unit/out/refcount/union_flex_array_member.rs
@@ -77,6 +77,7 @@ impl ByteRepr for node {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -143,3 +144,4 @@ fn main_0() -> i32 {
     libcc2rs::free_refcount(((*n.borrow()).clone() as Ptr<node>).to_any());
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_memset_memcpy.rs b/tests/unit/out/refcount/union_memset_memcpy.rs
index fa78907eb..350f19001 100644
--- a/tests/unit/out/refcount/union_memset_memcpy.rs
+++ b/tests/unit/out/refcount/union_memset_memcpy.rs
@@ -158,6 +158,7 @@ impl ByteRepr for Container {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -274,3 +275,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_nested.rs b/tests/unit/out/refcount/union_nested.rs
index 094fc897a..fb2f0bcd4 100644
--- a/tests/unit/out/refcount/union_nested.rs
+++ b/tests/unit/out/refcount/union_nested.rs
@@ -185,6 +185,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -233,3 +234,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_pointer_pun_address.rs b/tests/unit/out/refcount/union_pointer_pun_address.rs
index 4a0cb1bb4..74fdf4f51 100644
--- a/tests/unit/out/refcount/union_pointer_pun_address.rs
+++ b/tests/unit/out/refcount/union_pointer_pun_address.rs
@@ -59,6 +59,7 @@ impl ByteRepr for node_b {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -115,3 +116,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_pointer_pun_writethrough.rs b/tests/unit/out/refcount/union_pointer_pun_writethrough.rs
index dd2f9369f..4cae4ee76 100644
--- a/tests/unit/out/refcount/union_pointer_pun_writethrough.rs
+++ b/tests/unit/out/refcount/union_pointer_pun_writethrough.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -55,3 +56,4 @@ fn main_0() -> i32 {
     assert!(((((*x.borrow()) == 42_i64) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_struct_dual_use.rs b/tests/unit/out/refcount/union_struct_dual_use.rs
index e80895fae..077f2c689 100644
--- a/tests/unit/out/refcount/union_struct_dual_use.rs
+++ b/tests/unit/out/refcount/union_struct_dual_use.rs
@@ -104,6 +104,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -148,3 +149,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_tagged_many_arms.rs b/tests/unit/out/refcount/union_tagged_many_arms.rs
index e3acc24bc..0a2f0986b 100644
--- a/tests/unit/out/refcount/union_tagged_many_arms.rs
+++ b/tests/unit/out/refcount/union_tagged_many_arms.rs
@@ -88,6 +88,7 @@ impl ByteRepr for Slot {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -138,3 +139,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_tagged_simple.rs b/tests/unit/out/refcount/union_tagged_simple.rs
index aff8f0f9d..48303998b 100644
--- a/tests/unit/out/refcount/union_tagged_simple.rs
+++ b/tests/unit/out/refcount/union_tagged_simple.rs
@@ -80,6 +80,7 @@ impl ByteRepr for Event {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -109,3 +110,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_tagged_struct_arms.rs b/tests/unit/out/refcount/union_tagged_struct_arms.rs
index 4c31211b7..fdb584e3e 100644
--- a/tests/unit/out/refcount/union_tagged_struct_arms.rs
+++ b/tests/unit/out/refcount/union_tagged_struct_arms.rs
@@ -192,6 +192,7 @@ impl ByteRepr for Branch {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -330,3 +331,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_void_ptr_sized_deref.rs b/tests/unit/out/refcount/union_void_ptr_sized_deref.rs
index 53c01fc08..b0fc1b0d3 100644
--- a/tests/unit/out/refcount/union_void_ptr_sized_deref.rs
+++ b/tests/unit/out/refcount/union_void_ptr_sized_deref.rs
@@ -117,6 +117,7 @@ pub fn write_count_1(s: Ptr<Sink>, count: i64) {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -144,3 +145,4 @@ fn main_0() -> i32 {
     assert!((((((*buf16.borrow()) as i32) == 4660) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unique_ptr.rs b/tests/unit/out/refcount/unique_ptr.rs
index 057d2497d..ca8625c23 100644
--- a/tests/unit/out/refcount/unique_ptr.rs
+++ b/tests/unit/out/refcount/unique_ptr.rs
@@ -281,6 +281,7 @@ pub fn RndStuff_2() {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -315,3 +316,4 @@ impl SafePointerImpl for Ptr<SafePointer> {
         .prefix_inc();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unique_ptr_const_deref.rs b/tests/unit/out/refcount/unique_ptr_const_deref.rs
index 299f6780d..57161c825 100644
--- a/tests/unit/out/refcount/unique_ptr_const_deref.rs
+++ b/tests/unit/out/refcount/unique_ptr_const_deref.rs
@@ -39,6 +39,7 @@ pub fn write_val_1(h: Ptr<Holder>, v: i32) {
         .borrow_mut()) = (*v.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -49,3 +50,4 @@ fn main_0() -> i32 {
     assert!((({ read_val_0((h.as_pointer()),) }) == 42));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unique_ptr_deref_ops.rs b/tests/unit/out/refcount/unique_ptr_deref_ops.rs
index ca18efc53..446fb5f72 100644
--- a/tests/unit/out/refcount/unique_ptr_deref_ops.rs
+++ b/tests/unit/out/refcount/unique_ptr_deref_ops.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -21,3 +22,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 25));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unique_ptr_nested.rs b/tests/unit/out/refcount/unique_ptr_nested.rs
index 7f5be219b..87d28f906 100644
--- a/tests/unit/out/refcount/unique_ptr_nested.rs
+++ b/tests/unit/out/refcount/unique_ptr_nested.rs
@@ -54,6 +54,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -91,3 +92,4 @@ fn main_0() -> i32 {
     assert!((((*sum.borrow()) + (*(*b.borrow()).as_ref().unwrap().borrow())) == 135));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unique_ptr_small.rs b/tests/unit/out/refcount/unique_ptr_small.rs
index d22c425cc..8e94698e7 100644
--- a/tests/unit/out/refcount/unique_ptr_small.rs
+++ b/tests/unit/out/refcount/unique_ptr_small.rs
@@ -11,6 +11,7 @@ pub fn change_0(n: Ptr<Option<Value<i32>>>) {
     ((n).clone() as Ptr<Option<Value<i32>>>).write((*m.borrow_mut()).take());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!(((*(*n.borrow()).as_ref().unwrap().borrow()) == 20));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unique_ptr_struct.rs b/tests/unit/out/refcount/unique_ptr_struct.rs
index 46bdd37ac..b6d679858 100644
--- a/tests/unit/out/refcount/unique_ptr_struct.rs
+++ b/tests/unit/out/refcount/unique_ptr_struct.rs
@@ -41,6 +41,7 @@ pub fn sum_0(p: Point) -> i32 {
     return ((*(*p.borrow()).x.borrow()) + (*(*p.borrow()).y.borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -59,3 +60,4 @@ fn main_0() -> i32 {
     assert!(((*s.borrow()) == 30));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/unsigned.rs b/tests/unit/out/refcount/unsigned.rs
index b067c3972..83b42022f 100644
--- a/tests/unit/out/refcount/unsigned.rs
+++ b/tests/unit/out/refcount/unsigned.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     assert!(((*a.borrow()) == 255));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/user_defined_same_as_libc.rs b/tests/unit/out/refcount/user_defined_same_as_libc.rs
index fe6a55c51..5ff492969 100644
--- a/tests/unit/out/refcount/user_defined_same_as_libc.rs
+++ b/tests/unit/out/refcount/user_defined_same_as_libc.rs
@@ -14,6 +14,7 @@ pub fn fopen_0(path: Ptr<u8>, mode: Ptr<u8>) -> Ptr<CFile> {
     return Ptr::null();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     assert!(((((*fp.borrow()).is_null()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_chain.rs b/tests/unit/out/refcount/va_arg_chain.rs
index bd4afad0b..6ab011ede 100644
--- a/tests/unit/out/refcount/va_arg_chain.rs
+++ b/tests/unit/out/refcount/va_arg_chain.rs
@@ -31,6 +31,7 @@ pub fn top_level_2(n: i32, __args: &[VaArg]) -> i32 {
     return (*result.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -47,3 +48,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_concat.rs b/tests/unit/out/refcount/va_arg_concat.rs
index e736569cc..0d43414b3 100644
--- a/tests/unit/out/refcount/va_arg_concat.rs
+++ b/tests/unit/out/refcount/va_arg_concat.rs
@@ -23,6 +23,7 @@ pub fn sum_ints_0(first: i32, __args: &[VaArg]) -> i32 {
     return (*total.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -42,3 +43,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_conditional.rs b/tests/unit/out/refcount/va_arg_conditional.rs
index 0c71e8fdf..c2a0c4943 100644
--- a/tests/unit/out/refcount/va_arg_conditional.rs
+++ b/tests/unit/out/refcount/va_arg_conditional.rs
@@ -18,6 +18,7 @@ pub fn conditional_log_0(verbose: i32, fmt: Ptr<u8>, __args: &[VaArg]) -> i32 {
     return -1_i32;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -33,3 +34,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_copy.rs b/tests/unit/out/refcount/va_arg_copy.rs
index e58de7db8..3ade7e6ec 100644
--- a/tests/unit/out/refcount/va_arg_copy.rs
+++ b/tests/unit/out/refcount/va_arg_copy.rs
@@ -28,6 +28,7 @@ pub fn sum_with_copy_0(count: i32, __args: &[VaArg]) -> i32 {
     return ((*sum1.borrow()) + (*sum2.borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -37,3 +38,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_fn_ptr.rs b/tests/unit/out/refcount/va_arg_fn_ptr.rs
index 2025a4653..311b23386 100644
--- a/tests/unit/out/refcount/va_arg_fn_ptr.rs
+++ b/tests/unit/out/refcount/va_arg_fn_ptr.rs
@@ -52,6 +52,7 @@ pub fn not_supported_5(ctx: AnyPtr, fn_: FnPtr<fn(i32) -> i32>, extra: AnyPtr) -
     return -3_i32;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -81,3 +82,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_forward.rs b/tests/unit/out/refcount/va_arg_forward.rs
index 1fc4b38ec..7bf21bb08 100644
--- a/tests/unit/out/refcount/va_arg_forward.rs
+++ b/tests/unit/out/refcount/va_arg_forward.rs
@@ -27,6 +27,7 @@ pub fn outer_1(count: i32, __args: &[VaArg]) -> i32 {
     return (*result.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     assert!((((({ outer_1(0, &[]) }) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_mixed_int_ptr.rs b/tests/unit/out/refcount/va_arg_mixed_int_ptr.rs
index 7d48118b8..938b2e3ab 100644
--- a/tests/unit/out/refcount/va_arg_mixed_int_ptr.rs
+++ b/tests/unit/out/refcount/va_arg_mixed_int_ptr.rs
@@ -26,6 +26,7 @@ pub fn mixed_args_0(count: i32, __args: &[VaArg]) -> i32 {
     return (*total.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -54,3 +55,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_mixed_types.rs b/tests/unit/out/refcount/va_arg_mixed_types.rs
index d9426ab9a..36e594190 100644
--- a/tests/unit/out/refcount/va_arg_mixed_types.rs
+++ b/tests/unit/out/refcount/va_arg_mixed_types.rs
@@ -27,6 +27,7 @@ pub fn sum_mixed_0(count: i32, __args: &[VaArg]) -> i32 {
     return (*total.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -58,3 +59,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs b/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs
index 3fc7ae503..188fa6543 100644
--- a/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs
+++ b/tests/unit/out/refcount/va_arg_non_primitive_ptrs.rs
@@ -79,6 +79,7 @@ pub fn dispatch_0(option: i32, __args: &[VaArg]) -> i32 {
     return (*result.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -124,3 +125,4 @@ fn main_0() -> i32 {
     assert!(((((*outp.borrow()).is_null()) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_null_int_ptr.rs b/tests/unit/out/refcount/va_arg_null_int_ptr.rs
index 272eadb49..a83a325c4 100644
--- a/tests/unit/out/refcount/va_arg_null_int_ptr.rs
+++ b/tests/unit/out/refcount/va_arg_null_int_ptr.rs
@@ -24,6 +24,7 @@ pub fn first_nonnull_0(count: i32, __args: &[VaArg]) -> i32 {
     return (*result.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -49,3 +50,4 @@ fn main_0() -> i32 {
     assert!((((({ first_nonnull_0(1, &[(AnyPtr::default()).into(),]) }) == -1_i32) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_printf.rs b/tests/unit/out/refcount/va_arg_printf.rs
index 2f2f88961..3d106702a 100644
--- a/tests/unit/out/refcount/va_arg_printf.rs
+++ b/tests/unit/out/refcount/va_arg_printf.rs
@@ -35,6 +35,7 @@ pub fn lenf_2(fmt: Ptr<u8>, __args: &[VaArg]) -> i32 {
     return (*result.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -87,3 +88,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_promotion.rs b/tests/unit/out/refcount/va_arg_promotion.rs
index 08a30ddc5..79f642074 100644
--- a/tests/unit/out/refcount/va_arg_promotion.rs
+++ b/tests/unit/out/refcount/va_arg_promotion.rs
@@ -19,6 +19,7 @@ pub fn test_promotions_0(count: i32, __args: &[VaArg]) -> i32 {
     return (((*a.borrow()) + (*b.borrow())) + ((*c.borrow()) as i32));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_snprintf.rs b/tests/unit/out/refcount/va_arg_snprintf.rs
index 3b74afc0e..2d02e04da 100644
--- a/tests/unit/out/refcount/va_arg_snprintf.rs
+++ b/tests/unit/out/refcount/va_arg_snprintf.rs
@@ -18,6 +18,7 @@ pub fn extract_first_0(buf: Ptr<u8>, size: i32, fmt: Ptr<u8>, __args: &[VaArg])
     return (*n.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -50,3 +51,4 @@ fn main_0() -> i32 {
     assert!((((((*buf.borrow())[(0) as usize] as i32) == ('A' as i32)) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_struct_ctx.rs b/tests/unit/out/refcount/va_arg_struct_ctx.rs
index 56fd66a5c..8c269fb10 100644
--- a/tests/unit/out/refcount/va_arg_struct_ctx.rs
+++ b/tests/unit/out/refcount/va_arg_struct_ctx.rs
@@ -45,6 +45,7 @@ pub fn set_error_0(ctx: Ptr<context>, fmt: Ptr<u8>, __args: &[VaArg]) {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -70,3 +71,4 @@ fn main_0() -> i32 {
     assert!(((((*(*ctx.borrow()).last_error.borrow()) == 42) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_two_passes.rs b/tests/unit/out/refcount/va_arg_two_passes.rs
index 0483bb391..b70bca9a2 100644
--- a/tests/unit/out/refcount/va_arg_two_passes.rs
+++ b/tests/unit/out/refcount/va_arg_two_passes.rs
@@ -33,6 +33,7 @@ pub fn sum_then_product_0(first: i32, __args: &[VaArg]) -> i32 {
     return ((*sum.borrow()) + (*product.borrow()));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -41,3 +42,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/va_arg_void_ptr.rs b/tests/unit/out/refcount/va_arg_void_ptr.rs
index 6765e2733..1c9fd571e 100644
--- a/tests/unit/out/refcount/va_arg_void_ptr.rs
+++ b/tests/unit/out/refcount/va_arg_void_ptr.rs
@@ -65,6 +65,7 @@ pub fn registry_update_0(r: Ptr<registry>, field: field, __args: &[VaArg]) -> i3
     return (*result.borrow());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -105,3 +106,4 @@ fn main_0() -> i32 {
     assert!(((((*(*r.borrow()).level.borrow()) == 5_i64) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs
index cc388c6cb..f18c382a2 100644
--- a/tests/unit/out/refcount/vector.rs
+++ b/tests/unit/out/refcount/vector.rs
@@ -10,6 +10,7 @@ pub fn copy_0(copy_vector: Vec<i32>) {
     let copy_vector: Value<Vec<i32>> = Rc::new(RefCell::new(copy_vector));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -239,3 +240,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector2.rs b/tests/unit/out/refcount/vector2.rs
index 7db493050..633f2a2a2 100644
--- a/tests/unit/out/refcount/vector2.rs
+++ b/tests/unit/out/refcount/vector2.rs
@@ -53,6 +53,7 @@ pub fn fn_0(v: Ptr<Vec<i32>>, v3: Vec<i32>) {
     v.with_mut(|__v: &mut Vec<i32>| __v.push(20));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -66,3 +67,4 @@ fn main_0() -> i32 {
     ({ fn_0(v.as_pointer(), (*v2.borrow()).clone()) });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs
index dccd70df9..a9f51630b 100644
--- a/tests/unit/out/refcount/vector3.rs
+++ b/tests/unit/out/refcount/vector3.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -76,3 +77,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector_addr_of_back.rs b/tests/unit/out/refcount/vector_addr_of_back.rs
index ee1809644..346738646 100644
--- a/tests/unit/out/refcount/vector_addr_of_back.rs
+++ b/tests/unit/out/refcount/vector_addr_of_back.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     assert!(((*(*sink.borrow()).upgrade().deref()).len() == 0_usize));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector_iter_range_ctor.rs b/tests/unit/out/refcount/vector_iter_range_ctor.rs
index 04d9348a8..ca53e9dbd 100644
--- a/tests/unit/out/refcount/vector_iter_range_ctor.rs
+++ b/tests/unit/out/refcount/vector_iter_range_ctor.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -86,3 +87,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs
index 288910bdf..38be44525 100644
--- a/tests/unit/out/refcount/vector_with_allocator.rs
+++ b/tests/unit/out/refcount/vector_with_allocator.rs
@@ -88,6 +88,7 @@ pub fn fn_1(v: Ptr<Vec<i32>>, v3: Vec<i32>) {
     v.with_mut(|__v: &mut Vec<i32>| __v.push(20));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -377,3 +378,4 @@ impl TestAllocator_int_Impl for Ptr<TestAllocator_int_> {
         (*p.borrow()).delete_array();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/void_cast.rs b/tests/unit/out/refcount/void_cast.rs
index 2c50822bc..7ba0766b9 100644
--- a/tests/unit/out/refcount/void_cast.rs
+++ b/tests/unit/out/refcount/void_cast.rs
@@ -97,6 +97,7 @@ pub fn unused_noncopyable_param_5(x: Ptr<NonCopyable>) {
     &(*x.upgrade().deref());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -168,3 +169,6 @@ fn main_0() -> i32 {
     assert!(((*(*(*g.borrow()).value.borrow()).as_ref().unwrap().borrow()) == 9));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {
+    let _ = side_effect_counter_3.with(Value::clone);
+}
diff --git a/tests/unit/out/refcount/void_ptr_implicit_conversion.rs b/tests/unit/out/refcount/void_ptr_implicit_conversion.rs
index 67f65ddc5..3becb4783 100644
--- a/tests/unit/out/refcount/void_ptr_implicit_conversion.rs
+++ b/tests/unit/out/refcount/void_ptr_implicit_conversion.rs
@@ -16,6 +16,7 @@ pub fn bump_0(arg: AnyPtr) -> i32 {
     return ((*value.borrow()).read());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -29,3 +30,4 @@ fn main_0() -> i32 {
     assert!(((((*value.borrow()) == 7) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/void_return.rs b/tests/unit/out/refcount/void_return.rs
index 0cf54c6a0..a88ace26b 100644
--- a/tests/unit/out/refcount/void_return.rs
+++ b/tests/unit/out/refcount/void_return.rs
@@ -15,6 +15,7 @@ pub fn f1_0(first: Ptr<i32>, last: Ptr<i32>) {
     return;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -26,3 +27,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/void_round_trip.rs b/tests/unit/out/refcount/void_round_trip.rs
index b9cfec3cb..9a17e1295 100644
--- a/tests/unit/out/refcount/void_round_trip.rs
+++ b/tests/unit/out/refcount/void_round_trip.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -14,3 +15,4 @@ fn main_0() -> i32 {
     assert!((((((a.as_pointer()).to_any().reinterpret_cast::<i32>().read()) == 42) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/z_bit_cast.rs b/tests/unit/out/refcount/z_bit_cast.rs
index c627013ad..59bafee45 100644
--- a/tests/unit/out/refcount/z_bit_cast.rs
+++ b/tests/unit/out/refcount/z_bit_cast.rs
@@ -13,6 +13,7 @@ pub fn bit_cast_1(p: AnyPtr) {
     let p: Value<AnyPtr> = Rc::new(RefCell::new(p));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -37,3 +38,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/01_local.rs b/tests/unit/out/unsafe/01_local.rs
index dc0c7db36..19595a03c 100644
--- a/tests/unit/out/unsafe/01_local.rs
+++ b/tests/unit/out/unsafe/01_local.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     assert!(((a) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/02_address_taken.rs b/tests/unit/out/unsafe/02_address_taken.rs
index f5b37e4b1..fdad7b9d7 100644
--- a/tests/unit/out/unsafe/02_address_taken.rs
+++ b/tests/unit/out/unsafe/02_address_taken.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     assert!(((b) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/03_local_array.rs b/tests/unit/out/unsafe/03_local_array.rs
index bb1596d41..aef836f23 100644
--- a/tests/unit/out/unsafe/03_local_array.rs
+++ b/tests/unit/out/unsafe/03_local_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!((((arr1[(0) as usize]) + (arr1[(1) as usize])) == (7)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/04_address_taken_array.rs b/tests/unit/out/unsafe/04_address_taken_array.rs
index 73dd1ef69..00b1902f1 100644
--- a/tests/unit/out/unsafe/04_address_taken_array.rs
+++ b/tests/unit/out/unsafe/04_address_taken_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     assert!((((arr2[(0) as usize]) + (arr2[(1) as usize])) == (12)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/05_new.rs b/tests/unit/out/unsafe/05_new.rs
index 42805c7e0..3507f06b8 100644
--- a/tests/unit/out/unsafe/05_new.rs
+++ b/tests/unit/out/unsafe/05_new.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     ::std::mem::drop(Box::from_raw(d));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/06_new_array.rs b/tests/unit/out/unsafe/06_new_array.rs
index 57c72259f..2423b0d2c 100644
--- a/tests/unit/out/unsafe/06_new_array.rs
+++ b/tests/unit/out/unsafe/06_new_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/07_unique.rs b/tests/unit/out/unsafe/07_unique.rs
index 1cfbca6cb..e27a68d59 100644
--- a/tests/unit/out/unsafe/07_unique.rs
+++ b/tests/unit/out/unsafe/07_unique.rs
@@ -12,6 +12,7 @@ pub unsafe fn fn_0(mut u: Option<Box<i32>>) -> Option<Box<i32>> {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*f.as_deref_mut().unwrap()) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/08_unique_array.rs b/tests/unit/out/unsafe/08_unique_array.rs
index ce31524a1..52325f4c3 100644
--- a/tests/unit/out/unsafe/08_unique_array.rs
+++ b/tests/unit/out/unsafe/08_unique_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!((((g.as_mut().unwrap()[(0_usize)]) + (g.as_mut().unwrap()[(1_usize)])) == (27)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/09_references.rs b/tests/unit/out/unsafe/09_references.rs
index 73b50b7e1..cf7a32947 100644
--- a/tests/unit/out/unsafe/09_references.rs
+++ b/tests/unit/out/unsafe/09_references.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*h_ref1) + (*h_ref2)) == (34)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/10_struct.rs b/tests/unit/out/unsafe/10_struct.rs
index 82cce1464..48671d687 100644
--- a/tests/unit/out/unsafe/10_struct.rs
+++ b/tests/unit/out/unsafe/10_struct.rs
@@ -32,6 +32,7 @@ impl Graph {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     };
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/11_move.rs b/tests/unit/out/unsafe/11_move.rs
index e6a6359ea..416cf0cdc 100644
--- a/tests/unit/out/unsafe/11_move.rs
+++ b/tests/unit/out/unsafe/11_move.rs
@@ -17,6 +17,7 @@ pub unsafe fn change_0(n: *mut Option<Box<i32>>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*n.as_deref_mut().unwrap()) == (20)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/12_test.rs b/tests/unit/out/unsafe/12_test.rs
index 34a452804..4980993e8 100644
--- a/tests/unit/out/unsafe/12_test.rs
+++ b/tests/unit/out/unsafe/12_test.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/13_testing.rs b/tests/unit/out/unsafe/13_testing.rs
index 4825b2561..5251adcce 100644
--- a/tests/unit/out/unsafe/13_testing.rs
+++ b/tests/unit/out/unsafe/13_testing.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     (*(*p2)) = 3;
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/14_testing2.rs b/tests/unit/out/unsafe/14_testing2.rs
index 306009241..4ac973120 100644
--- a/tests/unit/out/unsafe/14_testing2.rs
+++ b/tests/unit/out/unsafe/14_testing2.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*ptr) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/__builtin_constant_p.rs b/tests/unit/out/unsafe/__builtin_constant_p.rs
index db75aaad5..f1546b993 100644
--- a/tests/unit/out/unsafe/__builtin_constant_p.rs
+++ b/tests/unit/out/unsafe/__builtin_constant_p.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     assert!((((1) + (2)) == (3)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/addr_of_global.rs b/tests/unit/out/unsafe/addr_of_global.rs
index 8b56bca96..25040e405 100644
--- a/tests/unit/out/unsafe/addr_of_global.rs
+++ b/tests/unit/out/unsafe/addr_of_global.rs
@@ -36,6 +36,7 @@ pub static mut obj_4: std::cell::LazyCell<Outer> = std::cell::LazyCell::new(|| u
 });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -62,3 +63,10 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const alpha_0);
+    std::cell::LazyCell::force(&*&raw const beta_1);
+    std::cell::LazyCell::force(&*&raw const shared_2);
+    std::cell::LazyCell::force(&*&raw const items_3);
+    std::cell::LazyCell::force(&*&raw const obj_4);
+}
diff --git a/tests/unit/out/unsafe/alloc_array.rs b/tests/unit/out/unsafe/alloc_array.rs
index d7b4467ca..75fd103cd 100644
--- a/tests/unit/out/unsafe/alloc_array.rs
+++ b/tests/unit/out/unsafe/alloc_array.rs
@@ -29,6 +29,7 @@ pub unsafe fn Consume_1(mut arr: Option<Box<[i32]>>, mut N: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { Consume_1(arr.take(), N,) }) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/anonymous-struct.rs b/tests/unit/out/unsafe/anonymous-struct.rs
index 59c69a7f3..50ed23b0a 100644
--- a/tests/unit/out/unsafe/anonymous-struct.rs
+++ b/tests/unit/out/unsafe/anonymous-struct.rs
@@ -58,6 +58,7 @@ pub struct Outer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -118,3 +119,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/anonymous-struct_c.rs b/tests/unit/out/unsafe/anonymous-struct_c.rs
index 1c9915d95..82e84bfe0 100644
--- a/tests/unit/out/unsafe/anonymous-struct_c.rs
+++ b/tests/unit/out/unsafe/anonymous-struct_c.rs
@@ -58,6 +58,7 @@ pub struct Outer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -114,3 +115,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/anonymous_enum.rs b/tests/unit/out/unsafe/anonymous_enum.rs
index 02028c3c4..c1b150a45 100644
--- a/tests/unit/out/unsafe/anonymous_enum.rs
+++ b/tests/unit/out/unsafe/anonymous_enum.rs
@@ -31,6 +31,7 @@ pub struct WithAnonField {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -52,3 +53,4 @@ unsafe fn main_0() -> i32 {
     assert!(((w.field as i32) == (anon_2_FIELD_B as i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/anonymous_enum_c.rs b/tests/unit/out/unsafe/anonymous_enum_c.rs
index 9b4052282..434bff853 100644
--- a/tests/unit/out/unsafe/anonymous_enum_c.rs
+++ b/tests/unit/out/unsafe/anonymous_enum_c.rs
@@ -31,6 +31,7 @@ pub struct WithAnonField {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -52,3 +53,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((w.field as u32) == ((anon_2_FIELD_B as i32) as u32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/array.rs b/tests/unit/out/unsafe/array.rs
index 75df0fc08..02062d163 100644
--- a/tests/unit/out/unsafe/array.rs
+++ b/tests/unit/out/unsafe/array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!(((fatorial) == (120)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/array_2d_default.rs b/tests/unit/out/unsafe/array_2d_default.rs
index f242a86e5..07e70fb4d 100644
--- a/tests/unit/out/unsafe/array_2d_default.rs
+++ b/tests/unit/out/unsafe/array_2d_default.rs
@@ -12,6 +12,7 @@ pub unsafe fn fill_row_0(mut row: *mut libc::c_char, mut c: libc::c_char) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((grid[(2) as usize][(5) as usize] as i32) == ('z' as i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/array_const_init.rs b/tests/unit/out/unsafe/array_const_init.rs
index ed58820bd..361315761 100644
--- a/tests/unit/out/unsafe/array_const_init.rs
+++ b/tests/unit/out/unsafe/array_const_init.rs
@@ -31,6 +31,7 @@ pub static mut s_0: std::cell::LazyCell<S> = std::cell::LazyCell::new(|| unsafe
 });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,6 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const s_0);
+}
diff --git a/tests/unit/out/unsafe/array_of_noncopy_struct.rs b/tests/unit/out/unsafe/array_of_noncopy_struct.rs
index 7fedfe8ce..25d0ac72a 100644
--- a/tests/unit/out/unsafe/array_of_noncopy_struct.rs
+++ b/tests/unit/out/unsafe/array_of_noncopy_struct.rs
@@ -14,6 +14,7 @@ pub struct NonCopy {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     assert!(((arr[(2) as usize].data.len()) == (0_usize)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/array_reference.rs b/tests/unit/out/unsafe/array_reference.rs
index bdf9acd12..bd2beeccf 100644
--- a/tests/unit/out/unsafe/array_reference.rs
+++ b/tests/unit/out/unsafe/array_reference.rs
@@ -64,6 +64,7 @@ pub unsafe fn total_len_9(names: *mut [*const libc::c_char; 2]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -101,3 +102,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { total_len_9(&mut names as *mut [*const libc::c_char; 2],) }) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/assert.rs b/tests/unit/out/unsafe/assert.rs
index 4f9006870..0144311de 100644
--- a/tests/unit/out/unsafe/assert.rs
+++ b/tests/unit/out/unsafe/assert.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     assert!(((1) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/assign_as_value.rs b/tests/unit/out/unsafe/assign_as_value.rs
index 16e13699e..ce60f44c4 100644
--- a/tests/unit/out/unsafe/assign_as_value.rs
+++ b/tests/unit/out/unsafe/assign_as_value.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((out as i32) == ('x' as i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/auto.rs b/tests/unit/out/unsafe/auto.rs
index 603ea1deb..1f02ba4d1 100644
--- a/tests/unit/out/unsafe/auto.rs
+++ b/tests/unit/out/unsafe/auto.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     assert!(((sum) == (3)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bool_condition_enum.rs b/tests/unit/out/unsafe/bool_condition_enum.rs
index 4a8e4bb7d..904f9d1d5 100644
--- a/tests/unit/out/unsafe/bool_condition_enum.rs
+++ b/tests/unit/out/unsafe/bool_condition_enum.rs
@@ -12,6 +12,7 @@ pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -36,3 +37,4 @@ unsafe fn main_0() -> i32 {
     assert!(!(b4));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bool_condition_enum_c.rs b/tests/unit/out/unsafe/bool_condition_enum_c.rs
index 116e65128..bbaf58b45 100644
--- a/tests/unit/out/unsafe/bool_condition_enum_c.rs
+++ b/tests/unit/out/unsafe/bool_condition_enum_c.rs
@@ -12,6 +12,7 @@ pub const Code_CODE_ERR: Code = 1;
 pub const Code_CODE_FATAL: Code = 2;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -36,3 +37,4 @@ unsafe fn main_0() -> i32 {
     assert!(((!(b4) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bool_condition_int.rs b/tests/unit/out/unsafe/bool_condition_int.rs
index 4e65984d2..fc70398a5 100644
--- a/tests/unit/out/unsafe/bool_condition_int.rs
+++ b/tests/unit/out/unsafe/bool_condition_int.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -67,3 +68,4 @@ unsafe fn main_0() -> i32 {
     assert!(b1);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bool_condition_int_c.rs b/tests/unit/out/unsafe/bool_condition_int_c.rs
index e0b28b557..476a4b704 100644
--- a/tests/unit/out/unsafe/bool_condition_int_c.rs
+++ b/tests/unit/out/unsafe/bool_condition_int_c.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -67,3 +68,4 @@ unsafe fn main_0() -> i32 {
     assert!(b1);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bool_condition_logical.rs b/tests/unit/out/unsafe/bool_condition_logical.rs
index a86aeab4f..a42c00483 100644
--- a/tests/unit/out/unsafe/bool_condition_logical.rs
+++ b/tests/unit/out/unsafe/bool_condition_logical.rs
@@ -23,6 +23,7 @@ pub unsafe fn returns_zero_3() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -128,3 +129,6 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const side_effect_0);
+}
diff --git a/tests/unit/out/unsafe/bool_condition_logical_c.rs b/tests/unit/out/unsafe/bool_condition_logical_c.rs
index b7c287f6d..00521fd6c 100644
--- a/tests/unit/out/unsafe/bool_condition_logical_c.rs
+++ b/tests/unit/out/unsafe/bool_condition_logical_c.rs
@@ -23,6 +23,7 @@ pub unsafe fn returns_zero_3() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -141,3 +142,6 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const side_effect_0);
+}
diff --git a/tests/unit/out/unsafe/bool_condition_ptr.rs b/tests/unit/out/unsafe/bool_condition_ptr.rs
index f32b311cf..5f40a9885 100644
--- a/tests/unit/out/unsafe/bool_condition_ptr.rs
+++ b/tests/unit/out/unsafe/bool_condition_ptr.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -48,3 +49,4 @@ unsafe fn main_0() -> i32 {
     assert!(!(b3));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bool_condition_ptr_c.rs b/tests/unit/out/unsafe/bool_condition_ptr_c.rs
index ab7bf6352..4841cc529 100644
--- a/tests/unit/out/unsafe/bool_condition_ptr_c.rs
+++ b/tests/unit/out/unsafe/bool_condition_ptr_c.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -48,3 +49,4 @@ unsafe fn main_0() -> i32 {
     assert!(((!(b3) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bool_printing.rs b/tests/unit/out/unsafe/bool_printing.rs
index 0716902dd..d54e47e97 100644
--- a/tests/unit/out/unsafe/bool_printing.rs
+++ b/tests/unit/out/unsafe/bool_printing.rs
@@ -14,6 +14,7 @@ pub unsafe fn bar_1() -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -88,3 +89,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/borrow_mut_opt.rs b/tests/unit/out/unsafe/borrow_mut_opt.rs
index 1aa8e5ae3..3543cd4db 100644
--- a/tests/unit/out/unsafe/borrow_mut_opt.rs
+++ b/tests/unit/out/unsafe/borrow_mut_opt.rs
@@ -61,6 +61,7 @@ pub unsafe fn convert_with_rhs_1() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -69,3 +70,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { convert_with_rhs_1() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bounded_struct_ptr.rs b/tests/unit/out/unsafe/bounded_struct_ptr.rs
index 6402905e5..b281e2617 100644
--- a/tests/unit/out/unsafe/bounded_struct_ptr.rs
+++ b/tests/unit/out/unsafe/bounded_struct_ptr.rs
@@ -14,6 +14,7 @@ pub struct Foo {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -25,3 +26,4 @@ unsafe fn main_0() -> i32 {
     assert!((((a) + ((*p2).x2)) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/break.rs b/tests/unit/out/unsafe/break.rs
index ad4f2bf09..381818ebf 100644
--- a/tests/unit/out/unsafe/break.rs
+++ b/tests/unit/out/unsafe/break.rs
@@ -31,6 +31,7 @@ pub unsafe fn for_test_0(n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { for_test_0(200,) }) == (400)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/bst.rs b/tests/unit/out/unsafe/bst.rs
index 1d5ffd9f1..d40652cc4 100644
--- a/tests/unit/out/unsafe/bst.rs
+++ b/tests/unit/out/unsafe/bst.rs
@@ -36,6 +36,7 @@ pub unsafe fn insert_1(mut node: *mut node_t, mut new_node: *mut node_t) -> *mut
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -80,3 +81,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/builtin.rs b/tests/unit/out/unsafe/builtin.rs
index b7856c2b1..dd0a64971 100644
--- a/tests/unit/out/unsafe/builtin.rs
+++ b/tests/unit/out/unsafe/builtin.rs
@@ -71,6 +71,7 @@ pub unsafe fn test_mul_overflow_long_long_9() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -87,3 +88,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_mul_overflow_long_long_9() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/builtin_types_compatible.rs b/tests/unit/out/unsafe/builtin_types_compatible.rs
index de474b947..16952ec55 100644
--- a/tests/unit/out/unsafe/builtin_types_compatible.rs
+++ b/tests/unit/out/unsafe/builtin_types_compatible.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -25,3 +26,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((0) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/byte.rs b/tests/unit/out/unsafe/byte.rs
index a48cf14c9..e6d687ddb 100644
--- a/tests/unit/out/unsafe/byte.rs
+++ b/tests/unit/out/unsafe/byte.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((b1) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/c_struct.rs b/tests/unit/out/unsafe/c_struct.rs
index ab4902089..0de37421e 100644
--- a/tests/unit/out/unsafe/c_struct.rs
+++ b/tests/unit/out/unsafe/c_struct.rs
@@ -43,6 +43,7 @@ pub struct Container {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -84,3 +85,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((c2.color as u32) == (2_u32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/cast.rs b/tests/unit/out/unsafe/cast.rs
index 5c8128cfc..fc9c815fc 100644
--- a/tests/unit/out/unsafe/cast.rs
+++ b/tests/unit/out/unsafe/cast.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     assert!(((size) == (1_usize)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs b/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs
index 8bbc75843..17c07b7b5 100644
--- a/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs
+++ b/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs
@@ -18,6 +18,7 @@ pub unsafe fn strlen_1(mut s: *mut libc::c_char) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/char_printing.rs b/tests/unit/out/unsafe/char_printing.rs
index 72076f398..8480d7a02 100644
--- a/tests/unit/out/unsafe/char_printing.rs
+++ b/tests/unit/out/unsafe/char_printing.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -115,3 +116,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/char_printing_cerr.rs b/tests/unit/out/unsafe/char_printing_cerr.rs
index acd53963c..d4862a382 100644
--- a/tests/unit/out/unsafe/char_printing_cerr.rs
+++ b/tests/unit/out/unsafe/char_printing_cerr.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -115,3 +116,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/class.rs b/tests/unit/out/unsafe/class.rs
index a2517775b..6636a867f 100644
--- a/tests/unit/out/unsafe/class.rs
+++ b/tests/unit/out/unsafe/class.rs
@@ -70,6 +70,7 @@ pub unsafe fn RandomRoute_0(route: *mut Route) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -102,3 +103,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/class_template_lazy_member.rs b/tests/unit/out/unsafe/class_template_lazy_member.rs
index 02dde48bd..05ad2e74d 100644
--- a/tests/unit/out/unsafe/class_template_lazy_member.rs
+++ b/tests/unit/out/unsafe/class_template_lazy_member.rs
@@ -33,6 +33,7 @@ impl Box_Point_ {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -45,3 +46,4 @@ unsafe fn main_0() -> i32 {
     assert!((((unsafe { Box_Point_::get(&mut p,) }).x) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/class_templates.rs b/tests/unit/out/unsafe/class_templates.rs
index bab75e91e..78ee0f8dc 100644
--- a/tests/unit/out/unsafe/class_templates.rs
+++ b/tests/unit/out/unsafe/class_templates.rs
@@ -86,6 +86,7 @@ impl MyContainer_float_ {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -129,3 +130,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { MyContainer_float_::empty(&fmc,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index 613407426..98899fea8 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -33,6 +33,7 @@ impl Default for Foo {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -247,3 +248,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/comma_operator.rs b/tests/unit/out/unsafe/comma_operator.rs
index 7defe1c34..692c7544f 100644
--- a/tests/unit/out/unsafe/comma_operator.rs
+++ b/tests/unit/out/unsafe/comma_operator.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -45,3 +46,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/complex_function.rs b/tests/unit/out/unsafe/complex_function.rs
index ad8fc5c3a..6755d1ed2 100644
--- a/tests/unit/out/unsafe/complex_function.rs
+++ b/tests/unit/out/unsafe/complex_function.rs
@@ -52,6 +52,7 @@ impl X4 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -250,3 +251,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/compound_assign_paren.rs b/tests/unit/out/unsafe/compound_assign_paren.rs
index ed312d68a..2988a76f9 100644
--- a/tests/unit/out/unsafe/compound_assign_paren.rs
+++ b/tests/unit/out/unsafe/compound_assign_paren.rs
@@ -13,6 +13,7 @@ pub struct Item {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*ptr).flags as i32) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/compound_assign_ref.rs b/tests/unit/out/unsafe/compound_assign_ref.rs
index 426080b35..6e0615058 100644
--- a/tests/unit/out/unsafe/compound_assign_ref.rs
+++ b/tests/unit/out/unsafe/compound_assign_ref.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*((v).first_mut().unwrap())) == (15)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/constexpr_function.rs b/tests/unit/out/unsafe/constexpr_function.rs
index 834672573..ca86502b9 100644
--- a/tests/unit/out/unsafe/constexpr_function.rs
+++ b/tests/unit/out/unsafe/constexpr_function.rs
@@ -33,6 +33,7 @@ impl P {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -49,3 +50,4 @@ unsafe fn main_0() -> i32 {
     assert!(((k) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/constructor.rs b/tests/unit/out/unsafe/constructor.rs
index 630023ec6..77b3345ad 100644
--- a/tests/unit/out/unsafe/constructor.rs
+++ b/tests/unit/out/unsafe/constructor.rs
@@ -34,6 +34,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -47,3 +48,6 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) == (18)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const total_0);
+}
diff --git a/tests/unit/out/unsafe/continue.rs b/tests/unit/out/unsafe/continue.rs
index 6db61b732..f188b5437 100644
--- a/tests/unit/out/unsafe/continue.rs
+++ b/tests/unit/out/unsafe/continue.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -61,3 +62,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (81)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/copy_assign.rs b/tests/unit/out/unsafe/copy_assign.rs
index 12b506b83..bbd899e00 100644
--- a/tests/unit/out/unsafe/copy_assign.rs
+++ b/tests/unit/out/unsafe/copy_assign.rs
@@ -105,6 +105,7 @@ impl Default for Holder {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -178,3 +179,6 @@ unsafe fn main_0() -> i32 {
     assert!(((r1.mark) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const assigns_0);
+}
diff --git a/tests/unit/out/unsafe/copy_ctor.rs b/tests/unit/out/unsafe/copy_ctor.rs
index 23da88110..353f76039 100644
--- a/tests/unit/out/unsafe/copy_ctor.rs
+++ b/tests/unit/out/unsafe/copy_ctor.rs
@@ -84,6 +84,7 @@ pub unsafe fn make_2(mut v: i32) -> Counted {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -134,3 +135,6 @@ unsafe fn main_0() -> i32 {
     assert!(((n2.mark) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const copies_0);
+}
diff --git a/tests/unit/out/unsafe/cout_alias.rs b/tests/unit/out/unsafe/cout_alias.rs
index 35d1841c2..e66f1da13 100644
--- a/tests/unit/out/unsafe/cout_alias.rs
+++ b/tests/unit/out/unsafe/cout_alias.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     write!((*os2), "hello\n",);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/cstring.rs b/tests/unit/out/unsafe/cstring.rs
index 79cd91665..ea810293d 100644
--- a/tests/unit/out/unsafe/cstring.rs
+++ b/tests/unit/out/unsafe/cstring.rs
@@ -353,6 +353,7 @@ pub unsafe fn test_strcasecmp_15() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -375,3 +376,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_strcasecmp_15() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/default.rs b/tests/unit/out/unsafe/default.rs
index dfee8f817..c8b2e3361 100644
--- a/tests/unit/out/unsafe/default.rs
+++ b/tests/unit/out/unsafe/default.rs
@@ -28,6 +28,7 @@ impl Default for Pointers {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -46,3 +47,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/default_function_arguments.rs b/tests/unit/out/unsafe/default_function_arguments.rs
index d52c03be5..3ee1ff59f 100644
--- a/tests/unit/out/unsafe/default_function_arguments.rs
+++ b/tests/unit/out/unsafe/default_function_arguments.rs
@@ -33,6 +33,7 @@ impl Default for Bar {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     assert!(((arr[(2) as usize].v) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/default_in_statics.rs b/tests/unit/out/unsafe/default_in_statics.rs
index d522fa046..fdf3ae354 100644
--- a/tests/unit/out/unsafe/default_in_statics.rs
+++ b/tests/unit/out/unsafe/default_in_statics.rs
@@ -137,6 +137,7 @@ pub unsafe fn check_local_static_5() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -195,3 +196,10 @@ unsafe fn main_0() -> i32 {
     (unsafe { check_local_static_5() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const static_fn_0);
+    std::cell::LazyCell::force(&*&raw const static_outer_1);
+    std::cell::LazyCell::force(&*&raw const static_inner_array_2);
+    std::cell::LazyCell::force(&*&raw const static_foo_3);
+    std::cell::LazyCell::force(&*&raw const static_foo_array_4);
+}
diff --git a/tests/unit/out/unsafe/destructor.rs b/tests/unit/out/unsafe/destructor.rs
index af70431d2..a860b4a78 100644
--- a/tests/unit/out/unsafe/destructor.rs
+++ b/tests/unit/out/unsafe/destructor.rs
@@ -141,6 +141,7 @@ impl Ordered {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -212,3 +213,8 @@ unsafe fn main_0() -> i32 {
     assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut order_1))[(2) as usize]) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const global_0);
+    std::cell::LazyCell::force(&*&raw const order_1);
+    std::cell::LazyCell::force(&*&raw const order_count_2);
+}
diff --git a/tests/unit/out/unsafe/do_while_continue.rs b/tests/unit/out/unsafe/do_while_continue.rs
index 787aa4909..6a1db1f66 100644
--- a/tests/unit/out/unsafe/do_while_continue.rs
+++ b/tests/unit/out/unsafe/do_while_continue.rs
@@ -42,6 +42,7 @@ pub unsafe fn nested_1() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -50,3 +51,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { nested_1() }) == (6)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/doubly_linked_list.rs b/tests/unit/out/unsafe/doubly_linked_list.rs
index f11bcec2a..cb9dbfc56 100644
--- a/tests/unit/out/unsafe/doubly_linked_list.rs
+++ b/tests/unit/out/unsafe/doubly_linked_list.rs
@@ -81,6 +81,7 @@ pub unsafe fn Tail_4(mut head: *mut Node) -> *mut Node {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -206,3 +207,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/dowhile.rs b/tests/unit/out/unsafe/dowhile.rs
index 973731a35..831fbe748 100644
--- a/tests/unit/out/unsafe/dowhile.rs
+++ b/tests/unit/out/unsafe/dowhile.rs
@@ -23,6 +23,7 @@ pub unsafe fn dowhile_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { dowhile_0(0,) }) == (202)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/empty_array_init.rs b/tests/unit/out/unsafe/empty_array_init.rs
index 46d7970a5..96aec284c 100644
--- a/tests/unit/out/unsafe/empty_array_init.rs
+++ b/tests/unit/out/unsafe/empty_array_init.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -15,3 +16,4 @@ unsafe fn main_0() -> i32 {
     let mut vec_: Vec<i32> = std::array::from_fn::<_, 3, _>(|_| Default::default()).to_vec();
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/empty_main.rs b/tests/unit/out/unsafe/empty_main.rs
index 08a4a0a4b..c916b5a09 100644
--- a/tests/unit/out/unsafe/empty_main.rs
+++ b/tests/unit/out/unsafe/empty_main.rs
@@ -17,8 +17,12 @@ pub fn main() {
         .map(|arg| arg.as_ptr() as *mut libc::c_char)
         .collect();
     argv.push(::std::ptr::null_mut());
-    unsafe { ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32) }
+    unsafe {
+        __cpp2rust_init_globals();
+        ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32)
+    }
 }
 unsafe fn main_0(mut _a0: i32, mut _a1: *mut *mut libc::c_char) -> i32 {
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/enum_comparisson_in_globals.rs b/tests/unit/out/unsafe/enum_comparisson_in_globals.rs
index 50a548dc5..171ee229e 100644
--- a/tests/unit/out/unsafe/enum_comparisson_in_globals.rs
+++ b/tests/unit/out/unsafe/enum_comparisson_in_globals.rs
@@ -13,6 +13,7 @@ pub static mut global_0: std::cell::LazyCell<i32> =
     std::cell::LazyCell::new(|| unsafe { (((E_A as i32) != (E_B as i32)) as i32) });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,6 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut global_0)) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const global_0);
+}
diff --git a/tests/unit/out/unsafe/enum_default_in_static.rs b/tests/unit/out/unsafe/enum_default_in_static.rs
index a6ac3fd39..737123acf 100644
--- a/tests/unit/out/unsafe/enum_default_in_static.rs
+++ b/tests/unit/out/unsafe/enum_default_in_static.rs
@@ -24,6 +24,7 @@ pub static mut config_0: std::cell::LazyCell<Config> = std::cell::LazyCell::new(
 });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,6 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const config_0);
+}
diff --git a/tests/unit/out/unsafe/enum_increment.rs b/tests/unit/out/unsafe/enum_increment.rs
index 780923f73..93c4ea436 100644
--- a/tests/unit/out/unsafe/enum_increment.rs
+++ b/tests/unit/out/unsafe/enum_increment.rs
@@ -13,6 +13,7 @@ pub const color_BLUE: color = 2;
 pub const color_COLOR_LAST: color = 3;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((c.prefix_dec() as u32) == ((color_RED as i32) as u32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/enum_int_interop.rs b/tests/unit/out/unsafe/enum_int_interop.rs
index 609e17ac4..349262bb2 100644
--- a/tests/unit/out/unsafe/enum_int_interop.rs
+++ b/tests/unit/out/unsafe/enum_int_interop.rs
@@ -82,6 +82,7 @@ pub unsafe fn make_color_6(mut n: i32) -> Color {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -196,3 +197,9 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const global_color_0);
+    std::cell::LazyCell::force(&*&raw const global_opt_1);
+    std::cell::LazyCell::force(&*&raw const global_tag_2);
+    std::cell::LazyCell::force(&*&raw const entries_3);
+}
diff --git a/tests/unit/out/unsafe/enum_int_interop_c.rs b/tests/unit/out/unsafe/enum_int_interop_c.rs
index 8c03454b7..a4493283c 100644
--- a/tests/unit/out/unsafe/enum_int_interop_c.rs
+++ b/tests/unit/out/unsafe/enum_int_interop_c.rs
@@ -82,6 +82,7 @@ pub unsafe fn make_color_6(mut n: i32) -> Color {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -230,3 +231,9 @@ unsafe fn main_0() -> i32 {
     assert!((((((*pe).opt as u32) == ((Option_OPT_A as i32) as u32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const global_color_0);
+    std::cell::LazyCell::force(&*&raw const global_opt_1);
+    std::cell::LazyCell::force(&*&raw const global_tag_2);
+    std::cell::LazyCell::force(&*&raw const entries_3);
+}
diff --git a/tests/unit/out/unsafe/enum_with_duplicated_values.rs b/tests/unit/out/unsafe/enum_with_duplicated_values.rs
index 334ffb3dc..ff4a426d4 100644
--- a/tests/unit/out/unsafe/enum_with_duplicated_values.rs
+++ b/tests/unit/out/unsafe/enum_with_duplicated_values.rs
@@ -13,6 +13,7 @@ pub const E_C: E = 2;
 pub const E_D: E = 4;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     assert!(((E_D as i32) == ((1) << (2))));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/errno.rs b/tests/unit/out/unsafe/errno.rs
index 36749fcab..1668c216d 100644
--- a/tests/unit/out/unsafe/errno.rs
+++ b/tests/unit/out/unsafe/errno.rs
@@ -37,6 +37,7 @@ pub unsafe fn test_errno_from_fseek_2() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -46,3 +47,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_errno_from_fseek_2() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/expr_as_bool_c.rs b/tests/unit/out/unsafe/expr_as_bool_c.rs
index bad91013a..8cdd6e0dc 100644
--- a/tests/unit/out/unsafe/expr_as_bool_c.rs
+++ b/tests/unit/out/unsafe/expr_as_bool_c.rs
@@ -17,6 +17,7 @@ pub unsafe fn both_null_2(mut s1: *const libc::c_char, mut s2: *const libc::c_ch
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -82,3 +83,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { both_null_2(p1, std::ptr::null(),) }) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/expr_as_bool_cpp.rs b/tests/unit/out/unsafe/expr_as_bool_cpp.rs
index a53819107..b65495ef1 100644
--- a/tests/unit/out/unsafe/expr_as_bool_cpp.rs
+++ b/tests/unit/out/unsafe/expr_as_bool_cpp.rs
@@ -17,6 +17,7 @@ pub unsafe fn both_null_2(mut s1: *const libc::c_char, mut s2: *const libc::c_ch
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -77,3 +78,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { both_null_2(p1, std::ptr::null(),) }) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/exprs.rs b/tests/unit/out/unsafe/exprs.rs
index 694056975..dd91d40ba 100644
--- a/tests/unit/out/unsafe/exprs.rs
+++ b/tests/unit/out/unsafe/exprs.rs
@@ -27,6 +27,7 @@ impl Y {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -66,3 +67,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x.x) == (100)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fatorial.rs b/tests/unit/out/unsafe/fatorial.rs
index 84ce95d85..56076d4f1 100644
--- a/tests/unit/out/unsafe/fatorial.rs
+++ b/tests/unit/out/unsafe/fatorial.rs
@@ -32,6 +32,7 @@ pub unsafe fn fatorial_by_ptr_2(mut n: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { fatorial_0(n,) }) == (720)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fcall.rs b/tests/unit/out/unsafe/fcall.rs
index 1606d9d00..7b93ff7d8 100644
--- a/tests/unit/out/unsafe/fcall.rs
+++ b/tests/unit/out/unsafe/fcall.rs
@@ -35,6 +35,7 @@ pub unsafe fn f1_2(mut x: f64, mut y: f64) -> f64 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { f1_2(1.0E+0, 2.0E+0,) }) == (-6_i32 as f64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fcntl.rs b/tests/unit/out/unsafe/fcntl.rs
index d40f4c94f..d76ec44c6 100644
--- a/tests/unit/out/unsafe/fcntl.rs
+++ b/tests/unit/out/unsafe/fcntl.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -55,3 +56,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fd_io.rs b/tests/unit/out/unsafe/fd_io.rs
index e629e621f..ce16c3f1a 100644
--- a/tests/unit/out/unsafe/fd_io.rs
+++ b/tests/unit/out/unsafe/fd_io.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -68,3 +69,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::unlink(path)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fd_set_macros.rs b/tests/unit/out/unsafe/fd_set_macros.rs
index 4eee8dabc..ddc229e41 100644
--- a/tests/unit/out/unsafe/fd_set_macros.rs
+++ b/tests/unit/out/unsafe/fd_set_macros.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -27,3 +28,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fflush_null.rs b/tests/unit/out/unsafe/fflush_null.rs
index 31b9496aa..cb88b9ebe 100644
--- a/tests/unit/out/unsafe/fflush_null.rs
+++ b/tests/unit/out/unsafe/fflush_null.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -15,3 +16,4 @@ unsafe fn main_0() -> i32 {
     let mut file_ptr: *mut ::libc::FILE = std::ptr::null_mut();
     return libc::fflush(file_ptr);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fft.rs b/tests/unit/out/unsafe/fft.rs
index 19ed836f2..bb82191e7 100644
--- a/tests/unit/out/unsafe/fft.rs
+++ b/tests/unit/out/unsafe/fft.rs
@@ -124,6 +124,7 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -174,3 +175,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/find.rs b/tests/unit/out/unsafe/find.rs
index 59fdc0274..cdc1d9e85 100644
--- a/tests/unit/out/unsafe/find.rs
+++ b/tests/unit/out/unsafe/find.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -47,3 +48,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr.rs b/tests/unit/out/unsafe/fn_ptr.rs
index dcaacdaf4..97acea7ee 100644
--- a/tests/unit/out/unsafe/fn_ptr.rs
+++ b/tests/unit/out/unsafe/fn_ptr.rs
@@ -17,6 +17,7 @@ pub unsafe fn foo_1(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { foo_1(fn_, (&mut a as *mut i32),) }) == (a)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_arity.rs b/tests/unit/out/unsafe/fn_ptr_arity.rs
index 912c17c47..64d49e907 100644
--- a/tests/unit/out/unsafe/fn_ptr_arity.rs
+++ b/tests/unit/out/unsafe/fn_ptr_arity.rs
@@ -26,6 +26,7 @@ pub unsafe fn foo_0(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -36,3 +37,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { (f).unwrap()(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,) }) == (22)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_array.rs b/tests/unit/out/unsafe/fn_ptr_array.rs
index c41968b93..4eae9273b 100644
--- a/tests/unit/out/unsafe/fn_ptr_array.rs
+++ b/tests/unit/out/unsafe/fn_ptr_array.rs
@@ -17,6 +17,7 @@ pub unsafe fn mul_2(mut a: i32, mut b: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((ops[(0) as usize]) != (Some(sub_1))));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_as_condition.rs b/tests/unit/out/unsafe/fn_ptr_as_condition.rs
index e4d6574c0..f3cd7cceb 100644
--- a/tests/unit/out/unsafe/fn_ptr_as_condition.rs
+++ b/tests/unit/out/unsafe/fn_ptr_as_condition.rs
@@ -16,6 +16,7 @@ pub unsafe fn maybe_call_1(mut cb: Option<unsafe fn(*mut i32)>, mut x: *mut i32)
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((c) == (6)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_cast.rs b/tests/unit/out/unsafe/fn_ptr_cast.rs
index 014c53873..7138271f4 100644
--- a/tests/unit/out/unsafe/fn_ptr_cast.rs
+++ b/tests/unit/out/unsafe/fn_ptr_cast.rs
@@ -62,6 +62,7 @@ pub unsafe fn test_call_through_cast_5() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -72,3 +73,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_call_through_cast_5() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_conditional.rs b/tests/unit/out/unsafe/fn_ptr_conditional.rs
index 1e8d5e9fe..a497969de 100644
--- a/tests/unit/out/unsafe/fn_ptr_conditional.rs
+++ b/tests/unit/out/unsafe/fn_ptr_conditional.rs
@@ -36,6 +36,7 @@ pub unsafe fn apply_4(mut fn_: Option<unsafe fn(i32) -> i32>, mut x: i32) -> i32
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -47,3 +48,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { apply_4(None, 5,) }) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_default_arg.rs b/tests/unit/out/unsafe/fn_ptr_default_arg.rs
index 43d6ddab8..dfd44d75e 100644
--- a/tests/unit/out/unsafe/fn_ptr_default_arg.rs
+++ b/tests/unit/out/unsafe/fn_ptr_default_arg.rs
@@ -18,6 +18,7 @@ pub unsafe fn apply_1(mut x: i32, mut fn_: Option<Option<unsafe fn(i32) -> i32>>
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { apply_1(5, Some(negate),) }) == (-5_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_global.rs b/tests/unit/out/unsafe/fn_ptr_global.rs
index a07053e2a..aaf4d2994 100644
--- a/tests/unit/out/unsafe/fn_ptr_global.rs
+++ b/tests/unit/out/unsafe/fn_ptr_global.rs
@@ -25,6 +25,7 @@ pub unsafe fn call_op_4(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,6 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { call_op_4(5,) }) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const g_op_2);
+}
diff --git a/tests/unit/out/unsafe/fn_ptr_reassign.rs b/tests/unit/out/unsafe/fn_ptr_reassign.rs
index 4c8b0e3ff..a9d9994af 100644
--- a/tests/unit/out/unsafe/fn_ptr_reassign.rs
+++ b/tests/unit/out/unsafe/fn_ptr_reassign.rs
@@ -17,6 +17,7 @@ pub unsafe fn mul_2(mut a: i32, mut b: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { (fn_).unwrap()(1, 1,) }) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_return.rs b/tests/unit/out/unsafe/fn_ptr_return.rs
index 5f3b8ec7e..202d0f88b 100644
--- a/tests/unit/out/unsafe/fn_ptr_return.rs
+++ b/tests/unit/out/unsafe/fn_ptr_return.rs
@@ -20,6 +20,7 @@ pub unsafe fn pick_2(mut choose_inc: i32) -> Option<unsafe fn(i32) -> i32> {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((f) != (g)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_stable_sort.rs b/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
index a0fd886ad..542064edc 100644
--- a/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
+++ b/tests/unit/out/unsafe/fn_ptr_stable_sort.rs
@@ -17,6 +17,7 @@ pub unsafe fn Compare_0(a: *const Item, b: *const Item) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     assert!(((v[(2_usize)].key) == (3)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs b/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs
index f46015634..3d9a40802 100644
--- a/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs
+++ b/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs
@@ -24,6 +24,7 @@ pub unsafe fn my_alternative_fwrite_1(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -194,3 +195,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_struct.rs b/tests/unit/out/unsafe/fn_ptr_struct.rs
index c8480075e..a31fab528 100644
--- a/tests/unit/out/unsafe/fn_ptr_struct.rs
+++ b/tests/unit/out/unsafe/fn_ptr_struct.rs
@@ -28,6 +28,7 @@ pub unsafe fn negate_1(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -48,3 +49,4 @@ unsafe fn main_0() -> i32 {
     assert!(((h1.cb) == (h2.cb)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_void_return.rs b/tests/unit/out/unsafe/fn_ptr_void_return.rs
index 4a98d7f1b..b316ac46e 100644
--- a/tests/unit/out/unsafe/fn_ptr_void_return.rs
+++ b/tests/unit/out/unsafe/fn_ptr_void_return.rs
@@ -17,6 +17,7 @@ pub unsafe fn run_2(mut fn_: Option<unsafe fn(*mut i32)>, mut x: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -33,3 +34,4 @@ unsafe fn main_0() -> i32 {
     assert!(((b) == (-10_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fn_ptr_vtable.rs b/tests/unit/out/unsafe/fn_ptr_vtable.rs
index 4d1863ec1..b83719c1d 100644
--- a/tests/unit/out/unsafe/fn_ptr_vtable.rs
+++ b/tests/unit/out/unsafe/fn_ptr_vtable.rs
@@ -36,6 +36,7 @@ pub unsafe fn int_destroy_3(mut p: *mut ::libc::c_void) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,6 @@ unsafe fn main_0() -> i32 {
     assert!((vt.get).is_none());
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const storage_0);
+}
diff --git a/tests/unit/out/unsafe/fopen.rs b/tests/unit/out/unsafe/fopen.rs
index 04f91a35d..0c619091b 100644
--- a/tests/unit/out/unsafe/fopen.rs
+++ b/tests/unit/out/unsafe/fopen.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     let mut file_ptr: *mut ::libc::FILE = libc::fopen(fname, mode);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/foreach.rs b/tests/unit/out/unsafe/foreach.rs
index 2855a4db9..d6d231fb2 100644
--- a/tests/unit/out/unsafe/foreach.rs
+++ b/tests/unit/out/unsafe/foreach.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!(((sum) == (45)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs
index 93399ada4..b4decd0fc 100644
--- a/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs
+++ b/tests/unit/out/unsafe/foreach_disjoint_field_borrow.rs
@@ -14,6 +14,7 @@ pub struct S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/foreach_double.rs b/tests/unit/out/unsafe/foreach_double.rs
index 708d9bd82..04948ac48 100644
--- a/tests/unit/out/unsafe/foreach_double.rs
+++ b/tests/unit/out/unsafe/foreach_double.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -62,3 +63,4 @@ unsafe fn main_0() -> i32 {
     assert!(((square) == (144)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/foreach_map.rs b/tests/unit/out/unsafe/foreach_map.rs
index 4a70fa140..d89aa4e86 100644
--- a/tests/unit/out/unsafe/foreach_map.rs
+++ b/tests/unit/out/unsafe/foreach_map.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((sum) == (7475_f64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/foreach_mut.rs b/tests/unit/out/unsafe/foreach_mut.rs
index b1b4a126b..4b5f3f91c 100644
--- a/tests/unit/out/unsafe/foreach_mut.rs
+++ b/tests/unit/out/unsafe/foreach_mut.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,4 @@ unsafe fn main_0() -> i32 {
     assert!(((sum) == (168)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/friend.rs b/tests/unit/out/unsafe/friend.rs
index 0b9d58f7a..2f7668a4d 100644
--- a/tests/unit/out/unsafe/friend.rs
+++ b/tests/unit/out/unsafe/friend.rs
@@ -55,6 +55,7 @@ pub unsafe fn declared_then_defined_6(d: *const D) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -85,3 +86,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { declared_then_defined_6(&d as *const D,) }) == (8)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fstat.rs b/tests/unit/out/unsafe/fstat.rs
index e1bea6a66..d45adbc22 100644
--- a/tests/unit/out/unsafe/fstat.rs
+++ b/tests/unit/out/unsafe/fstat.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::unlink(path)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/function_call.rs b/tests/unit/out/unsafe/function_call.rs
index a3b0975a2..35acce077 100644
--- a/tests/unit/out/unsafe/function_call.rs
+++ b/tests/unit/out/unsafe/function_call.rs
@@ -12,6 +12,7 @@ pub unsafe fn function_0(mut y: i32, mut z: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     assert!(((y) == (16)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/function_overloading.rs b/tests/unit/out/unsafe/function_overloading.rs
index 19cfa331e..5f6edb555 100644
--- a/tests/unit/out/unsafe/function_overloading.rs
+++ b/tests/unit/out/unsafe/function_overloading.rs
@@ -40,6 +40,7 @@ pub unsafe fn func_6(mut x: *mut i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -71,3 +72,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (13)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/global-initialization-using-global.rs b/tests/unit/out/unsafe/global-initialization-using-global.rs
index 93f718e9e..9b4c4a3df 100644
--- a/tests/unit/out/unsafe/global-initialization-using-global.rs
+++ b/tests/unit/out/unsafe/global-initialization-using-global.rs
@@ -12,6 +12,7 @@ pub static mut second_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(||
 });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,7 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const first_0);
+    std::cell::LazyCell::force(&*&raw const second_1);
+}
diff --git a/tests/unit/out/unsafe/global_init_side_effect.rs b/tests/unit/out/unsafe/global_init_side_effect.rs
index 82b0ae944..dc350ef35 100644
--- a/tests/unit/out/unsafe/global_init_side_effect.rs
+++ b/tests/unit/out/unsafe/global_init_side_effect.rs
@@ -21,6 +21,7 @@ pub static mut a_1: std::cell::LazyCell<S> = std::cell::LazyCell::new(|| unsafe
 pub static mut b_2: std::cell::LazyCell<S> = std::cell::LazyCell::new(|| unsafe { S::S({ 10 }) });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,8 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut total_0)) == (11)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const total_0);
+    std::cell::LazyCell::force(&*&raw const a_1);
+    std::cell::LazyCell::force(&*&raw const b_2);
+}
diff --git a/tests/unit/out/unsafe/global_non_const_init.rs b/tests/unit/out/unsafe/global_non_const_init.rs
index 98bc9f062..5a5d5b8fb 100644
--- a/tests/unit/out/unsafe/global_non_const_init.rs
+++ b/tests/unit/out/unsafe/global_non_const_init.rs
@@ -99,6 +99,7 @@ impl Default for Singleton {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -133,3 +134,14 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { Singleton::instance() }) == (unsafe { Singleton::instance() })));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const signature_3);
+    std::cell::LazyCell::force(&*&raw const single_4);
+    std::cell::LazyCell::force(&*&raw const from_call_5);
+    std::cell::LazyCell::force(&*&raw const depends_on_call_6);
+    std::cell::LazyCell::force(&*&raw const default_ctor_7);
+    std::cell::LazyCell::force(&*&raw const arg_ctor_8);
+    std::cell::LazyCell::force(&*&raw const str_9);
+    std::cell::LazyCell::force(&*&raw const inline_member_11);
+    std::cell::LazyCell::force(&*&raw const member_10);
+}
diff --git a/tests/unit/out/unsafe/global_pointers.rs b/tests/unit/out/unsafe/global_pointers.rs
index e25bb3ead..88ed3dd4f 100644
--- a/tests/unit/out/unsafe/global_pointers.rs
+++ b/tests/unit/out/unsafe/global_pointers.rs
@@ -40,6 +40,7 @@ pub static mut arr_of_pointers_2: std::cell::LazyCell<[*mut libc::c_char; 3]> =
     });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -58,3 +59,8 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const single_entry_0);
+    std::cell::LazyCell::force(&*&raw const entries_1);
+    std::cell::LazyCell::force(&*&raw const arr_of_pointers_2);
+}
diff --git a/tests/unit/out/unsafe/global_without_initializer.rs b/tests/unit/out/unsafe/global_without_initializer.rs
index 8b8f1c58f..3f8ba77bd 100644
--- a/tests/unit/out/unsafe/global_without_initializer.rs
+++ b/tests/unit/out/unsafe/global_without_initializer.rs
@@ -18,6 +18,7 @@ pub static mut file_1: std::cell::LazyCell<*mut ::libc::FILE> =
 pub static mut size_2: std::cell::LazyCell<usize> = std::cell::LazyCell::new(|| unsafe { 0_usize });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -27,3 +28,8 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut size_2)) == (0_usize)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const s_0);
+    std::cell::LazyCell::force(&*&raw const file_1);
+    std::cell::LazyCell::force(&*&raw const size_2);
+}
diff --git a/tests/unit/out/unsafe/goto_aggregate_default.rs b/tests/unit/out/unsafe/goto_aggregate_default.rs
index bb1719d3a..522ab992c 100644
--- a/tests/unit/out/unsafe/goto_aggregate_default.rs
+++ b/tests/unit/out/unsafe/goto_aggregate_default.rs
@@ -38,6 +38,7 @@ pub unsafe fn agg_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -46,3 +47,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { agg_0(1,) }) == (1)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/goto_backward.rs b/tests/unit/out/unsafe/goto_backward.rs
index 4966418a3..7adeb2972 100644
--- a/tests/unit/out/unsafe/goto_backward.rs
+++ b/tests/unit/out/unsafe/goto_backward.rs
@@ -27,6 +27,7 @@ pub unsafe fn retry_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { retry_0(4,) }) == (12)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/goto_cleanup.rs b/tests/unit/out/unsafe/goto_cleanup.rs
index b5e328f4c..fd6e6f9d3 100644
--- a/tests/unit/out/unsafe/goto_cleanup.rs
+++ b/tests/unit/out/unsafe/goto_cleanup.rs
@@ -123,6 +123,7 @@ pub unsafe fn via_arrays_4(mut fail: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -143,3 +144,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { via_arrays_4(1,) }) == (-1_i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/goto_loop_control.rs b/tests/unit/out/unsafe/goto_loop_control.rs
index e0d218670..359f83fdf 100644
--- a/tests/unit/out/unsafe/goto_loop_control.rs
+++ b/tests/unit/out/unsafe/goto_loop_control.rs
@@ -31,6 +31,7 @@ pub unsafe fn loopctl_0() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { loopctl_0() }) == (3)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/goto_multi_label.rs b/tests/unit/out/unsafe/goto_multi_label.rs
index b7eb8cdc6..73f8000a3 100644
--- a/tests/unit/out/unsafe/goto_multi_label.rs
+++ b/tests/unit/out/unsafe/goto_multi_label.rs
@@ -31,6 +31,7 @@ pub unsafe fn classify_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { classify_0(-2_i32,) }) == (-1_i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/goto_nested_label.rs b/tests/unit/out/unsafe/goto_nested_label.rs
index b33975c3d..90c842f63 100644
--- a/tests/unit/out/unsafe/goto_nested_label.rs
+++ b/tests/unit/out/unsafe/goto_nested_label.rs
@@ -33,6 +33,7 @@ pub unsafe fn scan_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { scan_0(2,) }) == (2010)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/goto_switch_fallthrough.rs b/tests/unit/out/unsafe/goto_switch_fallthrough.rs
index dfe4ad60a..8c621563f 100644
--- a/tests/unit/out/unsafe/goto_switch_fallthrough.rs
+++ b/tests/unit/out/unsafe/goto_switch_fallthrough.rs
@@ -34,6 +34,7 @@ pub unsafe fn sm_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { sm_0(9,) }) == (1100)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/goto_switch_self_case.rs b/tests/unit/out/unsafe/goto_switch_self_case.rs
index 5a0b5c2e8..e6eab3d04 100644
--- a/tests/unit/out/unsafe/goto_switch_self_case.rs
+++ b/tests/unit/out/unsafe/goto_switch_self_case.rs
@@ -26,6 +26,7 @@ pub unsafe fn sm_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { sm_0(7,) }) == (-1_i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
index ea15aba8e..a7f49420e 100644
--- a/tests/unit/out/unsafe/huffman.rs
+++ b/tests/unit/out/unsafe/huffman.rs
@@ -273,6 +273,7 @@ pub unsafe fn HuffmanCodes_5(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -320,3 +321,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ifaddrs.rs b/tests/unit/out/unsafe/ifaddrs.rs
index 44c3636e3..c5bd3e03f 100644
--- a/tests/unit/out/unsafe/ifaddrs.rs
+++ b/tests/unit/out/unsafe/ifaddrs.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -94,3 +95,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ignored_rule.rs b/tests/unit/out/unsafe/ignored_rule.rs
index 269343ca4..3ea972500 100644
--- a/tests/unit/out/unsafe/ignored_rule.rs
+++ b/tests/unit/out/unsafe/ignored_rule.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -15,3 +16,4 @@ unsafe fn main_0() -> i32 {
     let mut a: [[i32; 2]; 2] = [[1, 2], [3, 4]];
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/immutable-deref-on-func-call.rs b/tests/unit/out/unsafe/immutable-deref-on-func-call.rs
index 776255e67..eee8d2c92 100644
--- a/tests/unit/out/unsafe/immutable-deref-on-func-call.rs
+++ b/tests/unit/out/unsafe/immutable-deref-on-func-call.rs
@@ -18,6 +18,7 @@ impl Item {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     assert!(((result) == (11)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/immutable_unsigned_arithmetic.rs b/tests/unit/out/unsafe/immutable_unsigned_arithmetic.rs
index 89e6cc79b..ddd15f048 100644
--- a/tests/unit/out/unsafe/immutable_unsigned_arithmetic.rs
+++ b/tests/unit/out/unsafe/immutable_unsigned_arithmetic.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     (*p) = (*p).wrapping_add((*p));
     return ((*p) as i32);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/implicit_autoref.rs b/tests/unit/out/unsafe/implicit_autoref.rs
index 7c745b4dc..77a7038fa 100644
--- a/tests/unit/out/unsafe/implicit_autoref.rs
+++ b/tests/unit/out/unsafe/implicit_autoref.rs
@@ -16,6 +16,7 @@ pub unsafe fn write_through_0(mut p: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!((((&mut (*p))[(0_usize)]) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/implicit_ptr_cast.rs b/tests/unit/out/unsafe/implicit_ptr_cast.rs
index 51a51a673..9cb704ac7 100644
--- a/tests/unit/out/unsafe/implicit_ptr_cast.rs
+++ b/tests/unit/out/unsafe/implicit_ptr_cast.rs
@@ -11,6 +11,7 @@ pub unsafe fn write_ulong_0(mut p: *mut u64) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((x) == (42_usize)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/inet_pton_ntop.rs b/tests/unit/out/unsafe/inet_pton_ntop.rs
index 2f11f2292..a6429ab5a 100644
--- a/tests/unit/out/unsafe/inet_pton_ntop.rs
+++ b/tests/unit/out/unsafe/inet_pton_ntop.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -172,3 +173,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/init.rs b/tests/unit/out/unsafe/init.rs
index 5590090d0..d747c7dec 100644
--- a/tests/unit/out/unsafe/init.rs
+++ b/tests/unit/out/unsafe/init.rs
@@ -16,6 +16,7 @@ pub unsafe fn func_0() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     aa = (unsafe { func_0() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/init_list.rs b/tests/unit/out/unsafe/init_list.rs
index 79c702b87..6a316bcc8 100644
--- a/tests/unit/out/unsafe/init_list.rs
+++ b/tests/unit/out/unsafe/init_list.rs
@@ -9,6 +9,7 @@ use std::rc::Rc;
 pub unsafe fn f_0(mut list: Vec<i32>) {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { f_0(vec![1, 2, 3, 4]) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/initializer_list.rs b/tests/unit/out/unsafe/initializer_list.rs
index 29b620cef..3dccbc0ac 100644
--- a/tests/unit/out/unsafe/initializer_list.rs
+++ b/tests/unit/out/unsafe/initializer_list.rs
@@ -14,6 +14,7 @@ pub unsafe fn f_0(mut bytes: Vec<i32>) -> usize {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { f_0(vec![1, 2, 3,],) }) == (3_usize)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/int_to_bool_explicit.rs b/tests/unit/out/unsafe/int_to_bool_explicit.rs
index e904e9360..775fd82a8 100644
--- a/tests/unit/out/unsafe/int_to_bool_explicit.rs
+++ b/tests/unit/out/unsafe/int_to_bool_explicit.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(!(b2));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/int_to_bool_explicit_c.rs b/tests/unit/out/unsafe/int_to_bool_explicit_c.rs
index 6337d81c7..ea5a5bd83 100644
--- a/tests/unit/out/unsafe/int_to_bool_explicit_c.rs
+++ b/tests/unit/out/unsafe/int_to_bool_explicit_c.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(((!(b2) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ipproto_macros.rs b/tests/unit/out/unsafe/ipproto_macros.rs
index 0f911fa24..9e9fdb066 100644
--- a/tests/unit/out/unsafe/ipproto_macros.rs
+++ b/tests/unit/out/unsafe/ipproto_macros.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!((((((tcp) + (udp)) + (ip)) + (ip6)) == (64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/isatty.rs b/tests/unit/out/unsafe/isatty.rs
index 2bd8e9cb2..a61487013 100644
--- a/tests/unit/out/unsafe/isatty.rs
+++ b/tests/unit/out/unsafe/isatty.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -27,3 +28,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::unlink(path)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/iterator_freshness.rs b/tests/unit/out/unsafe/iterator_freshness.rs
index 7a7cc4a6c..cfb061d00 100644
--- a/tests/unit/out/unsafe/iterator_freshness.rs
+++ b/tests/unit/out/unsafe/iterator_freshness.rs
@@ -9,6 +9,7 @@ use std::rc::Rc;
 pub unsafe fn foo_0(mut a0: *mut i32) {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { foo_0(it) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/iterators.rs b/tests/unit/out/unsafe/iterators.rs
index 71256cef8..8ad8cde87 100644
--- a/tests/unit/out/unsafe/iterators.rs
+++ b/tests/unit/out/unsafe/iterators.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/keywords.rs b/tests/unit/out/unsafe/keywords.rs
index 07b3d71b1..c7d305bd7 100644
--- a/tests/unit/out/unsafe/keywords.rs
+++ b/tests/unit/out/unsafe/keywords.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     assert!(((in_) == (123)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/kruskal.rs b/tests/unit/out/unsafe/kruskal.rs
index cb3645305..dca1afa08 100644
--- a/tests/unit/out/unsafe/kruskal.rs
+++ b/tests/unit/out/unsafe/kruskal.rs
@@ -184,6 +184,7 @@ pub unsafe fn MSTKruskal_2(graph: *mut Graph) -> f64 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -228,3 +229,4 @@ unsafe fn main_0() -> i32 {
     assert!(((total_weight) == (19_f64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/lambda_capture_pass.rs b/tests/unit/out/unsafe/lambda_capture_pass.rs
index b987c95d5..900cca4ea 100644
--- a/tests/unit/out/unsafe/lambda_capture_pass.rs
+++ b/tests/unit/out/unsafe/lambda_capture_pass.rs
@@ -14,6 +14,7 @@ pub unsafe fn apply_1(mut fn_: impl Fn(i32) -> i32, mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/lambda_nested.rs b/tests/unit/out/unsafe/lambda_nested.rs
index a117ad168..d36a62c9c 100644
--- a/tests/unit/out/unsafe/lambda_nested.rs
+++ b/tests/unit/out/unsafe/lambda_nested.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/libc_char_ptr_field.rs b/tests/unit/out/unsafe/libc_char_ptr_field.rs
index dab67ef53..388f03062 100644
--- a/tests/unit/out/unsafe/libc_char_ptr_field.rs
+++ b/tests/unit/out/unsafe/libc_char_ptr_field.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     let mut dname: *mut libc::c_char = (*d).d_name.as_mut_ptr();
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/libc_struct_without_default.rs b/tests/unit/out/unsafe/libc_struct_without_default.rs
index 45147dbcf..9af37125c 100644
--- a/tests/unit/out/unsafe/libc_struct_without_default.rs
+++ b/tests/unit/out/unsafe/libc_struct_without_default.rs
@@ -34,6 +34,7 @@ impl Default for FieldIsLibcType {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -65,3 +66,4 @@ unsafe fn main_0() -> i32 {
     assert!(((filt.addr.sa_family as i32) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/linked_list.rs b/tests/unit/out/unsafe/linked_list.rs
index aaf26744e..705864d3c 100644
--- a/tests/unit/out/unsafe/linked_list.rs
+++ b/tests/unit/out/unsafe/linked_list.rs
@@ -52,6 +52,7 @@ pub unsafe fn Delete_2(mut head: *mut Node, mut val: i32) -> *mut Node {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -137,3 +138,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/local_anon_struct_collision.rs b/tests/unit/out/unsafe/local_anon_struct_collision.rs
index 4e0a72bd1..f438a92b9 100644
--- a/tests/unit/out/unsafe/local_anon_struct_collision.rs
+++ b/tests/unit/out/unsafe/local_anon_struct_collision.rs
@@ -32,6 +32,7 @@ pub unsafe fn second_2() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { second_2() }) == (30)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/loop_with_postfix_inc.rs b/tests/unit/out/unsafe/loop_with_postfix_inc.rs
index c76639714..adf09f39c 100644
--- a/tests/unit/out/unsafe/loop_with_postfix_inc.rs
+++ b/tests/unit/out/unsafe/loop_with_postfix_inc.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (101)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/lseek_ftruncate.rs b/tests/unit/out/unsafe/lseek_ftruncate.rs
index 9bbf1c69e..8aa4f8d2c 100644
--- a/tests/unit/out/unsafe/lseek_ftruncate.rs
+++ b/tests/unit/out/unsafe/lseek_ftruncate.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -61,3 +62,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::unlink(path)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/lvalue_ref_goto.rs b/tests/unit/out/unsafe/lvalue_ref_goto.rs
index 7a3f338cf..7258d42cb 100644
--- a/tests/unit/out/unsafe/lvalue_ref_goto.rs
+++ b/tests/unit/out/unsafe/lvalue_ref_goto.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     });
     panic!("ub: non-void function does not return a value")
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/macros.rs b/tests/unit/out/unsafe/macros.rs
index 4e8d4dbf1..a849f188f 100644
--- a/tests/unit/out/unsafe/macros.rs
+++ b/tests/unit/out/unsafe/macros.rs
@@ -11,6 +11,7 @@ pub unsafe fn log_0(mut file: *const libc::c_char, mut line: i32, mut func: *con
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { log_0(c"macros.cpp".as_ptr(), 9, c"main".as_ptr()) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/main.rs b/tests/unit/out/unsafe/main.rs
index 87b543428..6d1da7b88 100644
--- a/tests/unit/out/unsafe/main.rs
+++ b/tests/unit/out/unsafe/main.rs
@@ -17,7 +17,10 @@ pub fn main() {
         .map(|arg| arg.as_ptr() as *mut libc::c_char)
         .collect();
     argv.push(::std::ptr::null_mut());
-    unsafe { ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32) }
+    unsafe {
+        __cpp2rust_init_globals();
+        ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32)
+    }
 }
 unsafe fn main_0(mut argc: i32, mut argv: *mut *mut libc::c_char) -> i32 {
     let mut s: Vec<libc::c_char> = {
@@ -29,3 +32,4 @@ unsafe fn main_0(mut argc: i32, mut argv: *mut *mut libc::c_char) -> i32 {
     assert!((((argc) + (((s.len() - 1) > (0_usize)) as i32)) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/malloc_realloc_free.rs b/tests/unit/out/unsafe/malloc_realloc_free.rs
index 588a72190..f0e8c6da8 100644
--- a/tests/unit/out/unsafe/malloc_realloc_free.rs
+++ b/tests/unit/out/unsafe/malloc_realloc_free.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -110,3 +111,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs
index cb57763f1..9292286bf 100644
--- a/tests/unit/out/unsafe/map-reallocation.rs
+++ b/tests/unit/out/unsafe/map-reallocation.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -61,3 +62,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs
index f2cdfb246..225780bbc 100644
--- a/tests/unit/out/unsafe/map.rs
+++ b/tests/unit/out/unsafe/map.rs
@@ -14,6 +14,7 @@ pub unsafe fn bar_1(x: *mut u32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -149,3 +150,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/matmul.rs b/tests/unit/out/unsafe/matmul.rs
index f9ae8d015..02f6c6f43 100644
--- a/tests/unit/out/unsafe/matmul.rs
+++ b/tests/unit/out/unsafe/matmul.rs
@@ -58,6 +58,7 @@ pub unsafe fn matmul_1(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -78,3 +79,4 @@ unsafe fn main_0() -> i32 {
     assert!(((m3.as_mut().unwrap()[(0_usize)].as_mut().unwrap()[(0_usize)]) == (20)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/max.rs b/tests/unit/out/unsafe/max.rs
index 2a3616bcf..1e3e179ba 100644
--- a/tests/unit/out/unsafe/max.rs
+++ b/tests/unit/out/unsafe/max.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -50,3 +51,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((((r1) + (r2)) + (r3)) + (r4)) + (r5)) == (56)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/memcpy_overlap.rs b/tests/unit/out/unsafe/memcpy_overlap.rs
index 6455ac0ee..369351d2a 100644
--- a/tests/unit/out/unsafe/memcpy_overlap.rs
+++ b/tests/unit/out/unsafe/memcpy_overlap.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     assert!(((buf[(5) as usize] as i32) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/memcpy_struct_bytes.rs b/tests/unit/out/unsafe/memcpy_struct_bytes.rs
index 110b0a877..da7900c3f 100644
--- a/tests/unit/out/unsafe/memcpy_struct_bytes.rs
+++ b/tests/unit/out/unsafe/memcpy_struct_bytes.rs
@@ -14,6 +14,7 @@ pub struct point {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -45,3 +46,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((dst.y) == (7)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/memcpy_struct_struct.rs b/tests/unit/out/unsafe/memcpy_struct_struct.rs
index 02793af4d..d0238477e 100644
--- a/tests/unit/out/unsafe/memcpy_struct_struct.rs
+++ b/tests/unit/out/unsafe/memcpy_struct_struct.rs
@@ -14,6 +14,7 @@ pub struct Entry {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -83,3 +84,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/memset.rs b/tests/unit/out/unsafe/memset.rs
index bd991fbd2..22eb64526 100644
--- a/tests/unit/out/unsafe/memset.rs
+++ b/tests/unit/out/unsafe/memset.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((sum) == (50529027)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/min_max_ptr2ptr.rs b/tests/unit/out/unsafe/min_max_ptr2ptr.rs
index bcc9d9939..c2ede5d32 100644
--- a/tests/unit/out/unsafe/min_max_ptr2ptr.rs
+++ b/tests/unit/out/unsafe/min_max_ptr2ptr.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     assert!((((r1) + (r2)) == (30)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/move_assign.rs b/tests/unit/out/unsafe/move_assign.rs
index 81caf1145..866fa068a 100644
--- a/tests/unit/out/unsafe/move_assign.rs
+++ b/tests/unit/out/unsafe/move_assign.rs
@@ -66,6 +66,7 @@ pub unsafe fn make_0(mut v: i32) -> MoveOnly {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -118,3 +119,4 @@ unsafe fn main_0() -> i32 {
     assert!(((m2.mark) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/move_ctor.rs b/tests/unit/out/unsafe/move_ctor.rs
index a7614be60..507043ec3 100644
--- a/tests/unit/out/unsafe/move_ctor.rs
+++ b/tests/unit/out/unsafe/move_ctor.rs
@@ -59,6 +59,7 @@ pub unsafe fn make_1(mut v: i32) -> MoveOnly {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -92,3 +93,4 @@ unsafe fn main_0() -> i32 {
     assert!(((m2.mark) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/move_this.rs b/tests/unit/out/unsafe/move_this.rs
index a06da1535..f8169337a 100644
--- a/tests/unit/out/unsafe/move_this.rs
+++ b/tests/unit/out/unsafe/move_this.rs
@@ -57,6 +57,7 @@ pub unsafe fn consume_0(mut c: Chain) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -86,3 +87,4 @@ unsafe fn main_0() -> i32 {
     assert!(((f.v) == (31)) && ((e.v) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/nested_block_scope.rs b/tests/unit/out/unsafe/nested_block_scope.rs
index 161b140d5..7fd616088 100644
--- a/tests/unit/out/unsafe/nested_block_scope.rs
+++ b/tests/unit/out/unsafe/nested_block_scope.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -46,3 +47,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/nested_structs.rs b/tests/unit/out/unsafe/nested_structs.rs
index b93fed2de..30f8bd506 100644
--- a/tests/unit/out/unsafe/nested_structs.rs
+++ b/tests/unit/out/unsafe/nested_structs.rs
@@ -38,6 +38,7 @@ pub struct Level0_Level1_2 {
 pub struct Level0 {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -50,3 +51,4 @@ unsafe fn main_0() -> i32 {
         Level0_Level1_1_Level2_1_Level3_2 { x1: 5, x2: 6 };
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/netdb.rs b/tests/unit/out/unsafe/netdb.rs
index 3afa9b061..cdabe0275 100644
--- a/tests/unit/out/unsafe/netdb.rs
+++ b/tests/unit/out/unsafe/netdb.rs
@@ -206,6 +206,7 @@ pub unsafe fn test_null_hints_2() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -215,3 +216,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_null_hints_2() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/new.rs b/tests/unit/out/unsafe/new.rs
index 2bc1b8be6..e44244361 100644
--- a/tests/unit/out/unsafe/new.rs
+++ b/tests/unit/out/unsafe/new.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/new_alloc_array.rs b/tests/unit/out/unsafe/new_alloc_array.rs
index a64c155b0..80788cd88 100644
--- a/tests/unit/out/unsafe/new_alloc_array.rs
+++ b/tests/unit/out/unsafe/new_alloc_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (99)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/new_array.rs b/tests/unit/out/unsafe/new_array.rs
index c5411bed5..c4d91846b 100644
--- a/tests/unit/out/unsafe/new_array.rs
+++ b/tests/unit/out/unsafe/new_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/new_array_var_size.rs b/tests/unit/out/unsafe/new_array_var_size.rs
index 323b005f0..77df652c9 100644
--- a/tests/unit/out/unsafe/new_array_var_size.rs
+++ b/tests/unit/out/unsafe/new_array_var_size.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/new_bst.rs b/tests/unit/out/unsafe/new_bst.rs
index 5f0c700ee..b402927f5 100644
--- a/tests/unit/out/unsafe/new_bst.rs
+++ b/tests/unit/out/unsafe/new_bst.rs
@@ -49,6 +49,7 @@ pub unsafe fn del_2(mut node: *mut node_t) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -72,3 +73,4 @@ unsafe fn main_0() -> i32 {
     assert!(out);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/new_struct.rs b/tests/unit/out/unsafe/new_struct.rs
index b027d5719..9228459fd 100644
--- a/tests/unit/out/unsafe/new_struct.rs
+++ b/tests/unit/out/unsafe/new_struct.rs
@@ -14,6 +14,7 @@ pub struct Pair {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (3)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/no_direct_callee.rs b/tests/unit/out/unsafe/no_direct_callee.rs
index 311d4c171..87a625c30 100644
--- a/tests/unit/out/unsafe/no_direct_callee.rs
+++ b/tests/unit/out/unsafe/no_direct_callee.rs
@@ -17,6 +17,7 @@ pub unsafe fn test_1(mut fn_: Option<unsafe fn() -> bool>) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { test_1(Some(test1_0),) }) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/null_compare.rs b/tests/unit/out/unsafe/null_compare.rs
index 0e2da0290..bcfdbbf0b 100644
--- a/tests/unit/out/unsafe/null_compare.rs
+++ b/tests/unit/out/unsafe/null_compare.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((p).is_null()) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/null_in_statics.rs b/tests/unit/out/unsafe/null_in_statics.rs
index 98f4b718e..28e2ccf30 100644
--- a/tests/unit/out/unsafe/null_in_statics.rs
+++ b/tests/unit/out/unsafe/null_in_statics.rs
@@ -24,6 +24,7 @@ pub static mut p_zero_7: std::cell::LazyCell<*mut i32> =
     std::cell::LazyCell::new(|| unsafe { std::ptr::null_mut() });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -52,3 +53,13 @@ unsafe fn main_0() -> i32 {
     assert!((*std::cell::LazyCell::force_mut(&mut *&raw mut p_zero_7)).is_null());
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const p_mut_0);
+    std::cell::LazyCell::force(&*&raw const p_const_1);
+    std::cell::LazyCell::force(&*&raw const cp_2);
+    std::cell::LazyCell::force(&*&raw const arr_of_ptr_3);
+    std::cell::LazyCell::force(&*&raw const pp_4);
+    std::cell::LazyCell::force(&*&raw const const_arr_of_ptr_5);
+    std::cell::LazyCell::force(&*&raw const cp_explicit_null_6);
+    std::cell::LazyCell::force(&*&raw const p_zero_7);
+}
diff --git a/tests/unit/out/unsafe/offsetof.rs b/tests/unit/out/unsafe/offsetof.rs
index 560e04153..39be73497 100644
--- a/tests/unit/out/unsafe/offsetof.rs
+++ b/tests/unit/out/unsafe/offsetof.rs
@@ -29,6 +29,7 @@ impl Default for Frame {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -55,3 +56,4 @@ unsafe fn main_0() -> i32 {
     assert!(((total) == ((2_usize).wrapping_add(len))));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/opaque_forward_decl.rs b/tests/unit/out/unsafe/opaque_forward_decl.rs
index 9ccbee491..cb48bcb36 100644
--- a/tests/unit/out/unsafe/opaque_forward_decl.rs
+++ b/tests/unit/out/unsafe/opaque_forward_decl.rs
@@ -14,6 +14,7 @@ pub struct container {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -27,3 +28,4 @@ unsafe fn main_0() -> i32 {
 }
 #[derive(Clone, Copy, Default, ByteRepr)]
 pub struct opaque;
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/opaque_record_copy.rs b/tests/unit/out/unsafe/opaque_record_copy.rs
index 78e06fb59..4ac07000f 100644
--- a/tests/unit/out/unsafe/opaque_record_copy.rs
+++ b/tests/unit/out/unsafe/opaque_record_copy.rs
@@ -14,6 +14,7 @@ pub struct Wrapper_Probe_ {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
 }
 #[derive(Clone, Copy, Default, ByteRepr)]
 pub struct Probe;
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/opaque_then_defined.rs b/tests/unit/out/unsafe/opaque_then_defined.rs
index bdd386e0f..ba00f09b4 100644
--- a/tests/unit/out/unsafe/opaque_then_defined.rs
+++ b/tests/unit/out/unsafe/opaque_then_defined.rs
@@ -20,6 +20,7 @@ pub struct node {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -36,3 +37,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((l.size) == (1)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_arithmetic_free.rs b/tests/unit/out/unsafe/operator_arithmetic_free.rs
index 28a79422d..bdd82d796 100644
--- a/tests/unit/out/unsafe/operator_arithmetic_free.rs
+++ b/tests/unit/out/unsafe/operator_arithmetic_free.rs
@@ -72,6 +72,7 @@ pub unsafe fn operator_add_12(mut a: i32, b: *const S) -> S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -167,3 +168,4 @@ unsafe fn main_0() -> i32 {
     assert!((((unsafe { operator_add_12(1, &a as *const S,) }).v) == (8)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_arithmetic_member.rs b/tests/unit/out/unsafe/operator_arithmetic_member.rs
index c3166ce23..120cadba8 100644
--- a/tests/unit/out/unsafe/operator_arithmetic_member.rs
+++ b/tests/unit/out/unsafe/operator_arithmetic_member.rs
@@ -64,6 +64,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -89,3 +90,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_bitwise_free.rs b/tests/unit/out/unsafe/operator_bitwise_free.rs
index f6c11f71e..edf8358b8 100644
--- a/tests/unit/out/unsafe/operator_bitwise_free.rs
+++ b/tests/unit/out/unsafe/operator_bitwise_free.rs
@@ -41,6 +41,7 @@ pub unsafe fn operator_shr_5(a: *const S, mut n: i32) -> S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -91,3 +92,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_bitwise_member.rs b/tests/unit/out/unsafe/operator_bitwise_member.rs
index f4abca282..ded8c7217 100644
--- a/tests/unit/out/unsafe/operator_bitwise_member.rs
+++ b/tests/unit/out/unsafe/operator_bitwise_member.rs
@@ -43,6 +43,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     assert!((((unsafe { S::operator_shr(&a, 2,) }).v) == (3_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_defaulted.rs b/tests/unit/out/unsafe/operator_comparison_defaulted.rs
index 72c41b778..d786982f8 100644
--- a/tests/unit/out/unsafe/operator_comparison_defaulted.rs
+++ b/tests/unit/out/unsafe/operator_comparison_defaulted.rs
@@ -272,6 +272,7 @@ impl std::cmp::PartialEq for Secondary {
 impl std::cmp::Eq for Secondary {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -339,3 +340,4 @@ unsafe fn main_0() -> i32 {
     assert!(!(unsafe { Secondary::operator_lt(&s2, &s1 as *const Secondary,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_free.rs b/tests/unit/out/unsafe/operator_comparison_free.rs
index dea30f04a..b45b08629 100644
--- a/tests/unit/out/unsafe/operator_comparison_free.rs
+++ b/tests/unit/out/unsafe/operator_comparison_free.rs
@@ -61,6 +61,7 @@ pub unsafe fn operator_lt_7(mut a: i32, b: *const S) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -119,3 +120,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { operator_lt_7(0, &a as *const S,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_member.rs b/tests/unit/out/unsafe/operator_comparison_member.rs
index c10a280f1..7f6ef1217 100644
--- a/tests/unit/out/unsafe/operator_comparison_member.rs
+++ b/tests/unit/out/unsafe/operator_comparison_member.rs
@@ -60,6 +60,7 @@ impl std::cmp::PartialEq for S {
 impl std::cmp::Eq for S {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -77,3 +78,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { S::operator_lt_i32_const(&a, 5,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_mixed.rs b/tests/unit/out/unsafe/operator_comparison_mixed.rs
index 729ab83d2..db4d22353 100644
--- a/tests/unit/out/unsafe/operator_comparison_mixed.rs
+++ b/tests/unit/out/unsafe/operator_comparison_mixed.rs
@@ -54,6 +54,7 @@ pub unsafe fn operator_lt_6(a: *mut S, mut b: i32) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -86,3 +87,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
index 6fcf71c0f..3eb8fd586 100644
--- a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
@@ -49,6 +49,7 @@ impl std::cmp::PartialEq for S {
 impl std::cmp::Eq for S {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -76,3 +77,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_compound_assignment_free.rs b/tests/unit/out/unsafe/operator_compound_assignment_free.rs
index 5011fa878..04407634c 100644
--- a/tests/unit/out/unsafe/operator_compound_assignment_free.rs
+++ b/tests/unit/out/unsafe/operator_compound_assignment_free.rs
@@ -53,6 +53,7 @@ pub unsafe fn operator_shr_assign_9(a: *mut S, mut n: i32) -> *mut S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -121,3 +122,4 @@ unsafe fn main_0() -> i32 {
     assert!(((a.v) == (14_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_compound_assignment_member.rs b/tests/unit/out/unsafe/operator_compound_assignment_member.rs
index e18583784..3c10d621f 100644
--- a/tests/unit/out/unsafe/operator_compound_assignment_member.rs
+++ b/tests/unit/out/unsafe/operator_compound_assignment_member.rs
@@ -59,6 +59,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -101,3 +102,4 @@ unsafe fn main_0() -> i32 {
     assert!(((c.v) == (1_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_less_than.rs b/tests/unit/out/unsafe/operator_less_than.rs
index 94937ae46..cea0a7de4 100644
--- a/tests/unit/out/unsafe/operator_less_than.rs
+++ b/tests/unit/out/unsafe/operator_less_than.rs
@@ -47,6 +47,7 @@ impl std::cmp::PartialEq for Pair {
 impl std::cmp::Eq for Pair {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { Pair::operator_lt(&mut pair1, &pair2 as *const Pair,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_logical_free.rs b/tests/unit/out/unsafe/operator_logical_free.rs
index db3d5cd58..b18ce4079 100644
--- a/tests/unit/out/unsafe/operator_logical_free.rs
+++ b/tests/unit/out/unsafe/operator_logical_free.rs
@@ -22,6 +22,7 @@ pub unsafe fn operator_or_2(a: *const S, b: *const S) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -68,3 +69,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_logical_member.rs b/tests/unit/out/unsafe/operator_logical_member.rs
index d6854ea28..e9b53ace6 100644
--- a/tests/unit/out/unsafe/operator_logical_member.rs
+++ b/tests/unit/out/unsafe/operator_logical_member.rs
@@ -24,6 +24,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -48,3 +49,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_member_pointer_free.rs b/tests/unit/out/unsafe/operator_member_pointer_free.rs
index fb4920e46..a9ce2f551 100644
--- a/tests/unit/out/unsafe/operator_member_pointer_free.rs
+++ b/tests/unit/out/unsafe/operator_member_pointer_free.rs
@@ -33,6 +33,7 @@ pub unsafe fn operator_addr_1(s: *mut S) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -63,3 +64,4 @@ unsafe fn main_0() -> i32 {
     assert!(((s.data[(0) as usize]) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_member_pointer_member.rs b/tests/unit/out/unsafe/operator_member_pointer_member.rs
index e8b9ea3ca..7f42a2ea2 100644
--- a/tests/unit/out/unsafe/operator_member_pointer_member.rs
+++ b/tests/unit/out/unsafe/operator_member_pointer_member.rs
@@ -55,6 +55,7 @@ impl Default for S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -83,3 +84,6 @@ unsafe fn main_0() -> i32 {
     assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut table_0))[(1) as usize]) == (80)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const table_0);
+}
diff --git a/tests/unit/out/unsafe/operator_other_free.rs b/tests/unit/out/unsafe/operator_other_free.rs
index e927438f6..4fddf4379 100644
--- a/tests/unit/out/unsafe/operator_other_free.rs
+++ b/tests/unit/out/unsafe/operator_other_free.rs
@@ -18,6 +18,7 @@ pub unsafe fn operator_comma_0(a: *const S, b: *const S) -> S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_other_member.rs b/tests/unit/out/unsafe/operator_other_member.rs
index de4d9ced7..feb1ac6c3 100644
--- a/tests/unit/out/unsafe/operator_other_member.rs
+++ b/tests/unit/out/unsafe/operator_other_member.rs
@@ -43,6 +43,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -67,3 +68,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { Static::operator_call(6, 7,) }) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_overloads.rs b/tests/unit/out/unsafe/operator_overloads.rs
index 4a3046684..c3cf306bb 100644
--- a/tests/unit/out/unsafe/operator_overloads.rs
+++ b/tests/unit/out/unsafe/operator_overloads.rs
@@ -54,6 +54,7 @@ pub unsafe fn operator_eq_5(mut a: i64, b: *const S) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -96,3 +97,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { operator_eq_5(6_i64, &s as *const S,) }) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_qualifiers.rs b/tests/unit/out/unsafe/operator_qualifiers.rs
index 8fafa7fdb..85e663d42 100644
--- a/tests/unit/out/unsafe/operator_qualifiers.rs
+++ b/tests/unit/out/unsafe/operator_qualifiers.rs
@@ -42,6 +42,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -61,3 +62,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { S::operator_index_i32_const_lref(&cs, 2,) }) == (112)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_synonyms.rs b/tests/unit/out/unsafe/operator_synonyms.rs
index 38e7ac837..29a239aac 100644
--- a/tests/unit/out/unsafe/operator_synonyms.rs
+++ b/tests/unit/out/unsafe/operator_synonyms.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -32,3 +33,4 @@ unsafe fn main_0() -> i32 {
     assert!(((a) == (0_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_three_way.rs b/tests/unit/out/unsafe/operator_three_way.rs
index f4ee11545..ab459a363 100644
--- a/tests/unit/out/unsafe/operator_three_way.rs
+++ b/tests/unit/out/unsafe/operator_three_way.rs
@@ -43,6 +43,7 @@ impl std::cmp::PartialEq for S {
 impl std::cmp::Eq for S {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { S::operator_cmp(&a, &b as *const S,) }) == std::cmp::Ordering::Less);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_traits.rs b/tests/unit/out/unsafe/operator_traits.rs
index db355396f..95ab11b2c 100644
--- a/tests/unit/out/unsafe/operator_traits.rs
+++ b/tests/unit/out/unsafe/operator_traits.rs
@@ -130,6 +130,7 @@ pub struct Wrapped_int_ {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -216,3 +217,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*m.entry(Lt { v: 2 }).or_default().as_mut()) == (20)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/overload_mangling.rs b/tests/unit/out/unsafe/overload_mangling.rs
index 266814fd9..86108ba01 100644
--- a/tests/unit/out/unsafe/overload_mangling.rs
+++ b/tests/unit/out/unsafe/overload_mangling.rs
@@ -44,6 +44,7 @@ pub struct Box {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -61,3 +62,4 @@ unsafe fn main_0() -> i32 {
     assert!(((b.v) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pair.rs b/tests/unit/out/unsafe/pair.rs
index da0f99d85..d5f97d93f 100644
--- a/tests/unit/out/unsafe/pair.rs
+++ b/tests/unit/out/unsafe/pair.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     assert!(((p3.1) == (6)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pipe_io.rs b/tests/unit/out/unsafe/pipe_io.rs
index 2455e40d5..0f3f06e98 100644
--- a/tests/unit/out/unsafe/pipe_io.rs
+++ b/tests/unit/out/unsafe/pipe_io.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::close(fds[(0) as usize])) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pod.rs b/tests/unit/out/unsafe/pod.rs
index cf4af2608..34a9a4569 100644
--- a/tests/unit/out/unsafe/pod.rs
+++ b/tests/unit/out/unsafe/pod.rs
@@ -20,6 +20,7 @@ pub unsafe fn PODIncrement_0(pod: *mut POD) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((p2.x1) + (p2.x2)) + (p2.x3)) == (39)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_add_assign.rs b/tests/unit/out/unsafe/pointer_add_assign.rs
index ae312a38d..27af602b1 100644
--- a/tests/unit/out/unsafe/pointer_add_assign.rs
+++ b/tests/unit/out/unsafe/pointer_add_assign.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -59,3 +60,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_arithmetic.rs b/tests/unit/out/unsafe/pointer_arithmetic.rs
index f1171997c..f7468b61e 100644
--- a/tests/unit/out/unsafe/pointer_arithmetic.rs
+++ b/tests/unit/out/unsafe/pointer_arithmetic.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_array.rs b/tests/unit/out/unsafe/pointer_array.rs
index 0daf128be..57aa0534d 100644
--- a/tests/unit/out/unsafe/pointer_array.rs
+++ b/tests/unit/out/unsafe/pointer_array.rs
@@ -27,6 +27,7 @@ pub unsafe fn IncrementAll_0(s: *mut StackArray) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (3)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_call_offset.rs b/tests/unit/out/unsafe/pointer_call_offset.rs
index af0f5c025..fcfc5ce04 100644
--- a/tests/unit/out/unsafe/pointer_call_offset.rs
+++ b/tests/unit/out/unsafe/pointer_call_offset.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(mut p: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -32,3 +33,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (9)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_diff.rs b/tests/unit/out/unsafe/pointer_diff.rs
index fabf90cff..cf966b0ec 100644
--- a/tests/unit/out/unsafe/pointer_diff.rs
+++ b/tests/unit/out/unsafe/pointer_diff.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((p1 as usize - p0 as usize) / ::std::mem::size_of::<i32>()) as i64) == (4_i64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_eq.rs b/tests/unit/out/unsafe/pointer_eq.rs
index 94d7ce53a..43d493c5e 100644
--- a/tests/unit/out/unsafe/pointer_eq.rs
+++ b/tests/unit/out/unsafe/pointer_eq.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((arr_back.offset((1) as isize)) == (&mut arr[(1) as usize] as *mut i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_neq.rs b/tests/unit/out/unsafe/pointer_neq.rs
index 541a48069..0307df027 100644
--- a/tests/unit/out/unsafe/pointer_neq.rs
+++ b/tests/unit/out/unsafe/pointer_neq.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(!((p1) != (p2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_offset.rs b/tests/unit/out/unsafe/pointer_offset.rs
index 9c484327d..116c9863f 100644
--- a/tests/unit/out/unsafe/pointer_offset.rs
+++ b/tests/unit/out/unsafe/pointer_offset.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -48,3 +49,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (51)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_printf.rs b/tests/unit/out/unsafe/pointer_printf.rs
index 70a232cc5..a43ba89ff 100644
--- a/tests/unit/out/unsafe/pointer_printf.rs
+++ b/tests/unit/out/unsafe/pointer_printf.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     printf(c"%p %d".as_ptr() as *const i8, p, (*p));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_to_boolean.rs b/tests/unit/out/unsafe/pointer_to_boolean.rs
index 4339bec98..f7f390d1c 100644
--- a/tests/unit/out/unsafe/pointer_to_boolean.rs
+++ b/tests/unit/out/unsafe/pointer_to_boolean.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     assert!(!(!(x).is_null()));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_usize_arith.rs b/tests/unit/out/unsafe/pointer_usize_arith.rs
index 4ba8b70c0..f3953c319 100644
--- a/tests/unit/out/unsafe/pointer_usize_arith.rs
+++ b/tests/unit/out/unsafe/pointer_usize_arith.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -81,3 +82,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*back) == (17)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointers.rs b/tests/unit/out/unsafe/pointers.rs
index a0f449f10..dbc4ec662 100644
--- a/tests/unit/out/unsafe/pointers.rs
+++ b/tests/unit/out/unsafe/pointers.rs
@@ -41,6 +41,7 @@ pub unsafe fn Update_0(mut t: *mut Test) -> *mut Test {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -54,3 +55,4 @@ unsafe fn main_0() -> i32 {
     assert!((((((*t3).x) + ((*t2).x)) + (t1.x)) == (75)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/poll.rs b/tests/unit/out/unsafe/poll.rs
index 1f7ec1e0f..86c205704 100644
--- a/tests/unit/out/unsafe/poll.rs
+++ b/tests/unit/out/unsafe/poll.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -49,3 +50,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/polymorphism.rs b/tests/unit/out/unsafe/polymorphism.rs
index bb4009ca3..aadde158f 100644
--- a/tests/unit/out/unsafe/polymorphism.rs
+++ b/tests/unit/out/unsafe/polymorphism.rs
@@ -32,6 +32,7 @@ unsafe impl Animal for Cat {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -45,3 +46,4 @@ unsafe fn main_0() -> i32 {
     assert!((eat1) && (!(eat2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/printfs.rs b/tests/unit/out/unsafe/printfs.rs
index 636b51634..18f789ba9 100644
--- a/tests/unit/out/unsafe/printfs.rs
+++ b/tests/unit/out/unsafe/printfs.rs
@@ -24,6 +24,7 @@ pub unsafe fn fn2_1(v: *const Vec<libc::c_char>) -> *const Vec<libc::c_char> {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/prvalue-as-lvalue.rs b/tests/unit/out/unsafe/prvalue-as-lvalue.rs
index 935f53253..471054a92 100644
--- a/tests/unit/out/unsafe/prvalue-as-lvalue.rs
+++ b/tests/unit/out/unsafe/prvalue-as-lvalue.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(a: *const i32) -> *const i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*b) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ptr2ptr.rs b/tests/unit/out/unsafe/ptr2ptr.rs
index 0c2275073..56daa40a1 100644
--- a/tests/unit/out/unsafe/ptr2ptr.rs
+++ b/tests/unit/out/unsafe/ptr2ptr.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -25,3 +26,4 @@ unsafe fn main_0() -> i32 {
     out *= x;
     return out;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ptr_cast_init.rs b/tests/unit/out/unsafe/ptr_cast_init.rs
index 6afc27f8f..c4bee41a8 100644
--- a/tests/unit/out/unsafe/ptr_cast_init.rs
+++ b/tests/unit/out/unsafe/ptr_cast_init.rs
@@ -19,6 +19,7 @@ pub struct view {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -52,3 +53,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((sel).is_null()) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ptr_to_incomplete_struct.rs b/tests/unit/out/unsafe/ptr_to_incomplete_struct.rs
index 7c4d37cbd..ef5e3da85 100644
--- a/tests/unit/out/unsafe/ptr_to_incomplete_struct.rs
+++ b/tests/unit/out/unsafe/ptr_to_incomplete_struct.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((fp) == (fp2)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/push_emplace_back.rs b/tests/unit/out/unsafe/push_emplace_back.rs
index 9c295cd66..69eea8eae 100644
--- a/tests/unit/out/unsafe/push_emplace_back.rs
+++ b/tests/unit/out/unsafe/push_emplace_back.rs
@@ -79,6 +79,7 @@ pub unsafe fn self_ref_push_6(mut comps: *mut Vec<Chunk>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -120,3 +121,4 @@ unsafe fn main_0() -> i32 {
     assert!(((chunks[(2_usize)].data) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pwd.rs b/tests/unit/out/unsafe/pwd.rs
index 954b56760..88cb2172c 100644
--- a/tests/unit/out/unsafe/pwd.rs
+++ b/tests/unit/out/unsafe/pwd.rs
@@ -70,6 +70,7 @@ pub unsafe fn test_getpwuid_r_erange_3() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -80,3 +81,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_getpwuid_r_erange_3() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/qsort_bsearch.rs b/tests/unit/out/unsafe/qsort_bsearch.rs
index 2a1ff8a63..b63e4e0ef 100644
--- a/tests/unit/out/unsafe/qsort_bsearch.rs
+++ b/tests/unit/out/unsafe/qsort_bsearch.rs
@@ -13,6 +13,7 @@ pub unsafe fn cmp_int_0(mut a: *const ::libc::c_void, mut b: *const ::libc::c_vo
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -59,3 +60,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((miss).is_null()) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/random.rs b/tests/unit/out/unsafe/random.rs
index 22e4c969c..8b565f20f 100644
--- a/tests/unit/out/unsafe/random.rs
+++ b/tests/unit/out/unsafe/random.rs
@@ -60,6 +60,7 @@ pub unsafe fn foo_1(mut x1: i32, x2: *mut i32, mut x3: *mut i32, p2: *mut Pair,
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -221,3 +222,4 @@ unsafe fn main_0() -> i32 {
     let mut ptr2ptr_2: *mut *mut Pair = (&mut py1 as *mut *mut Pair);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/rebind.rs b/tests/unit/out/unsafe/rebind.rs
index 3f13e57b6..3a6e1f309 100644
--- a/tests/unit/out/unsafe/rebind.rs
+++ b/tests/unit/out/unsafe/rebind.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
index f2809b67e..7aca02a35 100644
--- a/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/unsafe/redundant_copy_in_conversion.rs
@@ -12,6 +12,7 @@ pub unsafe fn sink_0(mut it: UnsafeMapIterator<i32, i32>) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!(((r) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ref_calls.rs b/tests/unit/out/unsafe/ref_calls.rs
index f04d25059..c9b82d6e6 100644
--- a/tests/unit/out/unsafe/ref_calls.rs
+++ b/tests/unit/out/unsafe/ref_calls.rs
@@ -14,6 +14,7 @@ pub unsafe fn foo_1(x: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reference_wrapper.rs b/tests/unit/out/unsafe/reference_wrapper.rs
index 54d701985..0e55e8a50 100644
--- a/tests/unit/out/unsafe/reference_wrapper.rs
+++ b/tests/unit/out/unsafe/reference_wrapper.rs
@@ -21,6 +21,7 @@ pub unsafe fn read_1(mut ref_: *mut i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -89,3 +90,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/references.rs b/tests/unit/out/unsafe/references.rs
index 957787ebd..1a05bde36 100644
--- a/tests/unit/out/unsafe/references.rs
+++ b/tests/unit/out/unsafe/references.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/references2.rs b/tests/unit/out/unsafe/references2.rs
index 8e3254e50..e4a1b7467 100644
--- a/tests/unit/out/unsafe/references2.rs
+++ b/tests/unit/out/unsafe/references2.rs
@@ -12,6 +12,7 @@ pub unsafe fn change_0(p: *mut Option<Box<i32>>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*a.as_deref_mut().unwrap()) == (7)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/refs_as_args.rs b/tests/unit/out/unsafe/refs_as_args.rs
index 2c8923db1..06ff07bf2 100644
--- a/tests/unit/out/unsafe/refs_as_args.rs
+++ b/tests/unit/out/unsafe/refs_as_args.rs
@@ -19,6 +19,7 @@ pub unsafe fn more_refs_0(mut x1: i32, mut x2: i32, r1: *mut i32, r2: *const i32
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!((((x1) + (x2)) == (21)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast.rs b/tests/unit/out/unsafe/reinterpret_cast.rs
index de7383fd4..e6e0ded1a 100644
--- a/tests/unit/out/unsafe/reinterpret_cast.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*arr16.offset((1) as isize)) as i32) == (1027)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_aliased.rs b/tests/unit/out/unsafe/reinterpret_cast_aliased.rs
index 07b06f022..46bbbf807 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_aliased.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_aliased.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     assert!(((val) == (18441921396093008810_u64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_array_write.rs b/tests/unit/out/unsafe/reinterpret_cast_array_write.rs
index 95998a235..77a2aa422 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_array_write.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_array_write.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((arr[(3) as usize] as i32) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_chain.rs b/tests/unit/out/unsafe/reinterpret_cast_chain.rs
index ee944c2b0..5e4edaeee 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_chain.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_chain.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*words.offset((3) as isize)) as i32) == (65518)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_double.rs b/tests/unit/out/unsafe/reinterpret_cast_double.rs
index b8a678885..7b15e6555 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_double.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_double.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(((d) > (3.14E+0)) && ((d) < (3.15E+0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_empty_vec.rs b/tests/unit/out/unsafe/reinterpret_cast_empty_vec.rs
index fcd0a627e..26111f554 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_empty_vec.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_empty_vec.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     let mut bytes: *mut u16 = (v.as_mut_ptr() as *mut u16);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_float.rs b/tests/unit/out/unsafe/reinterpret_cast_float.rs
index 734ec2604..1351f10aa 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_float.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_float.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(((f) == (2.0E+0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_i16_u16.rs b/tests/unit/out/unsafe/reinterpret_cast_i16_u16.rs
index 0f8a06b38..a8168d53f 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_i16_u16.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_i16_u16.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((vals[(0) as usize] as i32) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_identity.rs b/tests/unit/out/unsafe/reinterpret_cast_identity.rs
index 723ede85e..bbfb0c0d8 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_identity.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_identity.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*back2) == (42_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_iterate.rs b/tests/unit/out/unsafe/reinterpret_cast_iterate.rs
index af3b6746e..0306de95b 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_iterate.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_iterate.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_large_array.rs b/tests/unit/out/unsafe/reinterpret_cast_large_array.rs
index 0c4ea77f1..88d172c48 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_large_array.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_large_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_new.rs b/tests/unit/out/unsafe/reinterpret_cast_new.rs
index 5e69fa71a..50efea753 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_new.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_new.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     ::std::mem::drop(Box::from_raw(p));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_new_array.rs b/tests/unit/out/unsafe/reinterpret_cast_new_array.rs
index 3bf70b44a..a3ced6328 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_new_array.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_new_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_oob_read.rs b/tests/unit/out/unsafe/reinterpret_cast_oob_read.rs
index 2c1192e35..43bcf18b2 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_oob_read.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_oob_read.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     &(x);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_oob_write.rs b/tests/unit/out/unsafe/reinterpret_cast_oob_write.rs
index 316a0f1db..920c7dbae 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_oob_write.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_oob_write.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     (*bytes.offset((4) as isize)) = 255_u8;
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_partial_overlap.rs b/tests/unit/out/unsafe/reinterpret_cast_partial_overlap.rs
index 8f7af66eb..7c79aae93 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_partial_overlap.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_partial_overlap.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     assert!(((arr[(1) as usize]) == (134678186_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_roundtrip.rs b/tests/unit/out/unsafe/reinterpret_cast_roundtrip.rs
index 2c4c52c47..ff28cca15 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_roundtrip.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_roundtrip.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*as_int) == (67305985)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_same_type.rs b/tests/unit/out/unsafe/reinterpret_cast_same_type.rs
index 6cf3469a8..895a6f1d6 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_same_type.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_same_type.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     assert!(((arr[(2) as usize] as i32) == (99)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_signed.rs b/tests/unit/out/unsafe/reinterpret_cast_signed.rs
index ace0accff..66c1f35c4 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_signed.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_signed.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*quarters.offset((3) as isize)) as i32) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_string.rs b/tests/unit/out/unsafe/reinterpret_cast_string.rs
index 0910babd9..125a88a55 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_string.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_string.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*bytes.offset((4) as isize)) as i32) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_struct.rs b/tests/unit/out/unsafe/reinterpret_cast_struct.rs
index 76cdd7097..e92e19a78 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_struct.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_struct.rs
@@ -14,6 +14,7 @@ pub struct Point {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*bytes.offset((7) as isize)) as i32) == (8)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_struct_to_struct.rs b/tests/unit/out/unsafe/reinterpret_cast_struct_to_struct.rs
index 21852fbef..cbc43d90e 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_struct_to_struct.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_struct_to_struct.rs
@@ -20,6 +20,7 @@ pub struct Pair {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((pt.x) == (42_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_u32_from_u8.rs b/tests/unit/out/unsafe/reinterpret_cast_u32_from_u8.rs
index 1d2fd3837..32166b74a 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_u32_from_u8.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_u32_from_u8.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*dwords.offset((1) as isize)) == (2427178479_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_undersize.rs b/tests/unit/out/unsafe/reinterpret_cast_undersize.rs
index 4504ce2f6..58804bb7e 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_undersize.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_undersize.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     &(val);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_vec_write.rs b/tests/unit/out/unsafe/reinterpret_cast_vec_write.rs
index 151b99a59..7a5fe604b 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_vec_write.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_vec_write.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     assert!(((vec_[(1_usize)]) == (134678271_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reinterpret_cast_zero_init.rs b/tests/unit/out/unsafe/reinterpret_cast_zero_init.rs
index c810d0669..009d9ec9b 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_zero_init.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_zero_init.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((val) == (3735928559_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/reserved_keywords.rs b/tests/unit/out/unsafe/reserved_keywords.rs
index ec361c5fb..ee6a7fe1d 100644
--- a/tests/unit/out/unsafe/reserved_keywords.rs
+++ b/tests/unit/out/unsafe/reserved_keywords.rs
@@ -93,6 +93,7 @@ pub unsafe fn foo_0(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -182,3 +183,4 @@ unsafe fn main_0() -> i32 {
         )
     });
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ret_rvalue_ref.rs b/tests/unit/out/unsafe/ret_rvalue_ref.rs
index 0f1092a05..23d35d1a3 100644
--- a/tests/unit/out/unsafe/ret_rvalue_ref.rs
+++ b/tests/unit/out/unsafe/ret_rvalue_ref.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(v: *mut i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/rule_of_five.rs b/tests/unit/out/unsafe/rule_of_five.rs
index 08662359f..83fbe69f0 100644
--- a/tests/unit/out/unsafe/rule_of_five.rs
+++ b/tests/unit/out/unsafe/rule_of_five.rs
@@ -111,6 +111,7 @@ pub unsafe fn make_3(mut size: i32) -> Buffer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -161,3 +162,8 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const alive_0);
+    std::cell::LazyCell::force(&*&raw const copies_1);
+    std::cell::LazyCell::force(&*&raw const moves_2);
+}
diff --git a/tests/unit/out/unsafe/rule_of_three.rs b/tests/unit/out/unsafe/rule_of_three.rs
index d3c7a2821..66ca0458e 100644
--- a/tests/unit/out/unsafe/rule_of_three.rs
+++ b/tests/unit/out/unsafe/rule_of_three.rs
@@ -83,6 +83,7 @@ pub unsafe fn sum_2(b: *const Buffer) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -127,3 +128,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const alive_0);
+    std::cell::LazyCell::force(&*&raw const copies_1);
+}
diff --git a/tests/unit/out/unsafe/rvalue_ref_general.rs b/tests/unit/out/unsafe/rvalue_ref_general.rs
index c5b6ce67c..29b9610e8 100644
--- a/tests/unit/out/unsafe/rvalue_ref_general.rs
+++ b/tests/unit/out/unsafe/rvalue_ref_general.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*p3) == (*i6)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/rvalue_ref_global.rs b/tests/unit/out/unsafe/rvalue_ref_global.rs
index d34ac8e9f..4f83cc715 100644
--- a/tests/unit/out/unsafe/rvalue_ref_global.rs
+++ b/tests/unit/out/unsafe/rvalue_ref_global.rs
@@ -11,6 +11,7 @@ pub static mut g_0: std::cell::LazyCell<*mut i32> =
     std::cell::LazyCell::new(|| unsafe { &mut __tmp_0 });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,6 @@ unsafe fn main_0() -> i32 {
     assert!(((*(*std::cell::LazyCell::force_mut(&mut *&raw mut g_0))) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const g_0);
+}
diff --git a/tests/unit/out/unsafe/rvalue_ref_goto.rs b/tests/unit/out/unsafe/rvalue_ref_goto.rs
index 4fb3660d7..1e6de0a0a 100644
--- a/tests/unit/out/unsafe/rvalue_ref_goto.rs
+++ b/tests/unit/out/unsafe/rvalue_ref_goto.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     });
     panic!("ub: non-void function does not return a value")
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/rvalue_struct.rs b/tests/unit/out/unsafe/rvalue_struct.rs
index 8d31bde04..c7128e7d7 100644
--- a/tests/unit/out/unsafe/rvalue_struct.rs
+++ b/tests/unit/out/unsafe/rvalue_struct.rs
@@ -20,6 +20,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*s2).b) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs b/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs
index 625d69f44..574c59266 100644
--- a/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs
+++ b/tests/unit/out/unsafe/scalar_builtin_construct_destruct.rs
@@ -15,6 +15,7 @@ pub unsafe fn zero_1() -> i64 {
 pub unsafe fn destroy_2(mut p: *mut i32) {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -31,3 +32,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/select.rs b/tests/unit/out/unsafe/select.rs
index 646f3103f..049eb563f 100644
--- a/tests/unit/out/unsafe/select.rs
+++ b/tests/unit/out/unsafe/select.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -77,3 +78,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/simple_function.rs b/tests/unit/out/unsafe/simple_function.rs
index 31bf54de4..b1043ae16 100644
--- a/tests/unit/out/unsafe/simple_function.rs
+++ b/tests/unit/out/unsafe/simple_function.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     assert!((((x) + (y)) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/simple_index.rs b/tests/unit/out/unsafe/simple_index.rs
index 98f29d043..1de75f20c 100644
--- a/tests/unit/out/unsafe/simple_index.rs
+++ b/tests/unit/out/unsafe/simple_index.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     assert!((v[(0_usize)] as bool));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/size_t_ssize_t.rs b/tests/unit/out/unsafe/size_t_ssize_t.rs
index 4405bea4c..86a83ba33 100644
--- a/tests/unit/out/unsafe/size_t_ssize_t.rs
+++ b/tests/unit/out/unsafe/size_t_ssize_t.rs
@@ -17,6 +17,7 @@ pub unsafe fn sub_signed_2(mut a: isize, mut b: isize) -> isize {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -162,3 +163,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((n).wrapping_rem(7_usize)) as i32) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/snprintf.rs b/tests/unit/out/unsafe/snprintf.rs
index c8bfbe46f..3cd9dd237 100644
--- a/tests/unit/out/unsafe/snprintf.rs
+++ b/tests/unit/out/unsafe/snprintf.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -239,3 +240,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/socket_listen.rs b/tests/unit/out/unsafe/socket_listen.rs
index ca55cbf7b..d65abff73 100644
--- a/tests/unit/out/unsafe/socket_listen.rs
+++ b/tests/unit/out/unsafe/socket_listen.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::close(s)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/socket_open_close.rs b/tests/unit/out/unsafe/socket_open_close.rs
index 6f8ccf39d..1e170162c 100644
--- a/tests/unit/out/unsafe/socket_open_close.rs
+++ b/tests/unit/out/unsafe/socket_open_close.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -17,3 +18,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::close(s)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/socket_transparent_union.rs b/tests/unit/out/unsafe/socket_transparent_union.rs
index 2bada8802..64f5614fb 100644
--- a/tests/unit/out/unsafe/socket_transparent_union.rs
+++ b/tests/unit/out/unsafe/socket_transparent_union.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/socket_type_constants.rs b/tests/unit/out/unsafe/socket_type_constants.rs
index c7af392ea..3fc5d8f84 100644
--- a/tests/unit/out/unsafe/socket_type_constants.rs
+++ b/tests/unit/out/unsafe/socket_type_constants.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -16,3 +17,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::SOCK_DGRAM) == (2)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/sockopt.rs b/tests/unit/out/unsafe/sockopt.rs
index 354dbf5f7..884f9d06f 100644
--- a/tests/unit/out/unsafe/sockopt.rs
+++ b/tests/unit/out/unsafe/sockopt.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -51,3 +52,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::close(s)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/sort.rs b/tests/unit/out/unsafe/sort.rs
index 448788351..617896f2e 100644
--- a/tests/unit/out/unsafe/sort.rs
+++ b/tests/unit/out/unsafe/sort.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
index c8383e39c..052383f72 100644
--- a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(((v[(0_usize)]) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/stable_sort.rs b/tests/unit/out/unsafe/stable_sort.rs
index 7427395af..31a9210dc 100644
--- a/tests/unit/out/unsafe/stable_sort.rs
+++ b/tests/unit/out/unsafe/stable_sort.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -36,3 +37,4 @@ unsafe fn main_0() -> i32 {
     };
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/static_function_vars_same_name.rs b/tests/unit/out/unsafe/static_function_vars_same_name.rs
index 8ea972464..a51c1d968 100644
--- a/tests/unit/out/unsafe/static_function_vars_same_name.rs
+++ b/tests/unit/out/unsafe/static_function_vars_same_name.rs
@@ -16,6 +16,7 @@ pub unsafe fn b_2() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { b_2() }) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/static_local.rs b/tests/unit/out/unsafe/static_local.rs
index 14f93bd27..58e4d479f 100644
--- a/tests/unit/out/unsafe/static_local.rs
+++ b/tests/unit/out/unsafe/static_local.rs
@@ -21,6 +21,7 @@ pub unsafe fn foo_0() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { foo_0() }) + (unsafe { foo_0() })) + (unsafe { foo_0() })) == (15)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/static_shadow.rs b/tests/unit/out/unsafe/static_shadow.rs
index 7ececeb03..2113d756b 100644
--- a/tests/unit/out/unsafe/static_shadow.rs
+++ b/tests/unit/out/unsafe/static_shadow.rs
@@ -19,6 +19,7 @@ pub unsafe fn read_global_3() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,6 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { read_global_3() }) == (5)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const value_0);
+}
diff --git a/tests/unit/out/unsafe/static_var_in_class.rs b/tests/unit/out/unsafe/static_var_in_class.rs
index 3d500e77e..bec8580bb 100644
--- a/tests/unit/out/unsafe/static_var_in_class.rs
+++ b/tests/unit/out/unsafe/static_var_in_class.rs
@@ -21,6 +21,7 @@ pub static mut inner_const_1: std::cell::LazyCell<i32> = std::cell::LazyCell::ne
 pub struct S {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,7 @@ unsafe fn main_0() -> i32 {
     assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut inner_const_1)) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const inner_const_0);
+    std::cell::LazyCell::force(&*&raw const inner_const_1);
+}
diff --git a/tests/unit/out/unsafe/stdcopy.rs b/tests/unit/out/unsafe/stdcopy.rs
index 43938cfb1..12a4672c0 100644
--- a/tests/unit/out/unsafe/stdcopy.rs
+++ b/tests/unit/out/unsafe/stdcopy.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     };
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/stdcopy_ostream.rs b/tests/unit/out/unsafe/stdcopy_ostream.rs
index f88d2ad38..f298bd329 100644
--- a/tests/unit/out/unsafe/stdcopy_ostream.rs
+++ b/tests/unit/out/unsafe/stdcopy_ostream.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -32,3 +33,4 @@ unsafe fn main_0() -> i32 {
     libc::unlink(file.as_ptr());
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/stdio.rs b/tests/unit/out/unsafe/stdio.rs
index e80d25579..7dc51d129 100644
--- a/tests/unit/out/unsafe/stdio.rs
+++ b/tests/unit/out/unsafe/stdio.rs
@@ -48,6 +48,7 @@ pub unsafe fn test_fileno_3() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -58,3 +59,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_fileno_3() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/stdio_nofd.rs b/tests/unit/out/unsafe/stdio_nofd.rs
index 0382ace12..59f6a758b 100644
--- a/tests/unit/out/unsafe/stdio_nofd.rs
+++ b/tests/unit/out/unsafe/stdio_nofd.rs
@@ -314,6 +314,7 @@ pub unsafe fn test_setvbuf_6() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -327,3 +328,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_setvbuf_6() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/stdlib_h.rs b/tests/unit/out/unsafe/stdlib_h.rs
index a61ef3ad8..7beb16be4 100644
--- a/tests/unit/out/unsafe/stdlib_h.rs
+++ b/tests/unit/out/unsafe/stdlib_h.rs
@@ -74,6 +74,7 @@ pub unsafe fn test_realpath_1() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -82,3 +83,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_realpath_1() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/stdmin_fpoint.rs b/tests/unit/out/unsafe/stdmin_fpoint.rs
index 176c095da..34f42cfd9 100644
--- a/tests/unit/out/unsafe/stdmin_fpoint.rs
+++ b/tests/unit/out/unsafe/stdmin_fpoint.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     };
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/stmt_expr.rs b/tests/unit/out/unsafe/stmt_expr.rs
index 9a205d882..a308f16e0 100644
--- a/tests/unit/out/unsafe/stmt_expr.rs
+++ b/tests/unit/out/unsafe/stmt_expr.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/strdup.rs b/tests/unit/out/unsafe/strdup.rs
index b60b8a55c..41b0bade3 100644
--- a/tests/unit/out/unsafe/strdup.rs
+++ b/tests/unit/out/unsafe/strdup.rs
@@ -13,6 +13,7 @@ pub struct record {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -60,3 +61,4 @@ unsafe fn main_0() -> i32 {
     libcc2rs::free_unsafe(((*r).name as *mut libc::c_char as *mut ::libc::c_void));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string.rs b/tests/unit/out/unsafe/string.rs
index 03f632dfd..607e5c415 100644
--- a/tests/unit/out/unsafe/string.rs
+++ b/tests/unit/out/unsafe/string.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -313,3 +314,4 @@ unsafe fn main_0() -> i32 {
     assert!((((t4).wrapping_add((s5.len() - 1))) == (139_usize)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string2.rs b/tests/unit/out/unsafe/string2.rs
index 720dcc783..25b43fa05 100644
--- a/tests/unit/out/unsafe/string2.rs
+++ b/tests/unit/out/unsafe/string2.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_escape.rs b/tests/unit/out/unsafe/string_escape.rs
index 3acb7398a..1359c377f 100644
--- a/tests/unit/out/unsafe/string_escape.rs
+++ b/tests/unit/out/unsafe/string_escape.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -74,3 +75,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_h.rs b/tests/unit/out/unsafe/string_h.rs
index fbe4f5800..8360ab292 100644
--- a/tests/unit/out/unsafe/string_h.rs
+++ b/tests/unit/out/unsafe/string_h.rs
@@ -504,6 +504,7 @@ pub unsafe fn test_strcasecmp_14() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -525,3 +526,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_strcasecmp_14() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literal_interior_null.rs b/tests/unit/out/unsafe/string_literal_interior_null.rs
index 5e00475e8..c514daddb 100644
--- a/tests/unit/out/unsafe/string_literal_interior_null.rs
+++ b/tests/unit/out/unsafe/string_literal_interior_null.rs
@@ -26,6 +26,7 @@ pub static mut g_packet_1: std::cell::LazyCell<*const libc::c_char> =
     });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,6 @@ unsafe fn main_0() -> i32 {
     assert!(((d) == (('b' as libc::c_char) as i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const g_packet_1);
+}
diff --git a/tests/unit/out/unsafe/string_literal_ptr_init.rs b/tests/unit/out/unsafe/string_literal_ptr_init.rs
index 2f6812f7a..507a5c1c4 100644
--- a/tests/unit/out/unsafe/string_literal_ptr_init.rs
+++ b/tests/unit/out/unsafe/string_literal_ptr_init.rs
@@ -41,6 +41,7 @@ pub static mut table_1: std::cell::LazyCell<[label; 2]> = std::cell::LazyCell::n
 });
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -118,3 +119,6 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const table_1);
+}
diff --git a/tests/unit/out/unsafe/string_literals.rs b/tests/unit/out/unsafe/string_literals.rs
index 0001addf8..e3e7090f5 100644
--- a/tests/unit/out/unsafe/string_literals.rs
+++ b/tests/unit/out/unsafe/string_literals.rs
@@ -10,6 +10,7 @@ pub unsafe fn foo_mut_0(mut str: *mut libc::c_char) {}
 pub unsafe fn foo_const_1(mut str: *const libc::c_char) {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { foo_const_1(inited_through_init_list.as_ptr()) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literals_c.rs b/tests/unit/out/unsafe/string_literals_c.rs
index 80da83d03..036cdd921 100644
--- a/tests/unit/out/unsafe/string_literals_c.rs
+++ b/tests/unit/out/unsafe/string_literals_c.rs
@@ -10,6 +10,7 @@ pub unsafe fn foo_mut_0(mut str: *mut libc::c_char) {}
 pub unsafe fn foo_const_1(mut str: *const libc::c_char) {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -50,3 +51,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { foo_const_1(inited_through_init_list.as_ptr()) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literals_concat.rs b/tests/unit/out/unsafe/string_literals_concat.rs
index befe367d2..eb7006a09 100644
--- a/tests/unit/out/unsafe/string_literals_concat.rs
+++ b/tests/unit/out/unsafe/string_literals_concat.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*split_pieces.offset((9) as isize)) as i32) == (('\0' as libc::c_char) as i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literals_concat_c.rs b/tests/unit/out/unsafe/string_literals_concat_c.rs
index 0dc9f60a4..01c773dfc 100644
--- a/tests/unit/out/unsafe/string_literals_concat_c.rs
+++ b/tests/unit/out/unsafe/string_literals_concat_c.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -25,3 +26,4 @@ unsafe fn main_0() -> i32 {
     assert!((((((*split_pieces.offset((9) as isize)) as i32) == ('\0' as i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literals_return.rs b/tests/unit/out/unsafe/string_literals_return.rs
index c58b2a687..4a2cc3f3d 100644
--- a/tests/unit/out/unsafe/string_literals_return.rs
+++ b/tests/unit/out/unsafe/string_literals_return.rs
@@ -20,6 +20,7 @@ pub unsafe fn get_branch_2(mut x: i32) -> *const libc::c_char {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*d.offset((12) as isize)) as i32) == (('\0' as libc::c_char) as i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literals_return_c.rs b/tests/unit/out/unsafe/string_literals_return_c.rs
index 8380b35ef..f63bf5819 100644
--- a/tests/unit/out/unsafe/string_literals_return_c.rs
+++ b/tests/unit/out/unsafe/string_literals_return_c.rs
@@ -20,6 +20,7 @@ pub unsafe fn get_branch_2(mut x: i32) -> *const libc::c_char {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!((((((*d.offset((12) as isize)) as i32) == ('\0' as i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literals_sized.rs b/tests/unit/out/unsafe/string_literals_sized.rs
index 2e67b5813..858f75063 100644
--- a/tests/unit/out/unsafe/string_literals_sized.rs
+++ b/tests/unit/out/unsafe/string_literals_sized.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/string_literals_sized_c.rs b/tests/unit/out/unsafe/string_literals_sized_c.rs
index 8d8a6190d..58ecb87c8 100644
--- a/tests/unit/out/unsafe/string_literals_sized_c.rs
+++ b/tests/unit/out/unsafe/string_literals_sized_c.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/strlen.rs b/tests/unit/out/unsafe/strlen.rs
index 7b1a6e585..c8f72f8bf 100644
--- a/tests/unit/out/unsafe/strlen.rs
+++ b/tests/unit/out/unsafe/strlen.rs
@@ -15,6 +15,7 @@ pub unsafe fn strlen_0(mut ptr: *mut libc::c_char) -> u32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { strlen_0((&mut string[(0) as usize] as *mut libc::c_char),) }) == (5_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/strlen_diff.rs b/tests/unit/out/unsafe/strlen_diff.rs
index 219f5d654..745c60350 100644
--- a/tests/unit/out/unsafe/strlen_diff.rs
+++ b/tests/unit/out/unsafe/strlen_diff.rs
@@ -16,6 +16,7 @@ pub unsafe fn strlen_0(mut s: *const libc::c_char) -> usize {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -32,3 +33,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { strlen_0((&s[(0) as usize] as *const libc::c_char),) }) == (6_usize)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/strlen_rec.rs b/tests/unit/out/unsafe/strlen_rec.rs
index 534e146fe..33e5baf75 100644
--- a/tests/unit/out/unsafe/strlen_rec.rs
+++ b/tests/unit/out/unsafe/strlen_rec.rs
@@ -15,6 +15,7 @@ pub unsafe fn strlen_0(mut s: *const libc::c_char, mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { strlen_0((&s[(0) as usize] as *const libc::c_char), 0,) }) == (3)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/struct_ctor.rs b/tests/unit/out/unsafe/struct_ctor.rs
index 45ce263a0..6bd3229ae 100644
--- a/tests/unit/out/unsafe/struct_ctor.rs
+++ b/tests/unit/out/unsafe/struct_ctor.rs
@@ -31,6 +31,7 @@ pub unsafe fn foo_0(x: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/struct_default_ctor.rs b/tests/unit/out/unsafe/struct_default_ctor.rs
index e21f18922..6b92abc62 100644
--- a/tests/unit/out/unsafe/struct_default_ctor.rs
+++ b/tests/unit/out/unsafe/struct_default_ctor.rs
@@ -25,6 +25,7 @@ impl Default for S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((s.b as i32) == (true as i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/struct_ptr.rs b/tests/unit/out/unsafe/struct_ptr.rs
index 3393de337..04d274f4c 100644
--- a/tests/unit/out/unsafe/struct_ptr.rs
+++ b/tests/unit/out/unsafe/struct_ptr.rs
@@ -13,6 +13,7 @@ pub struct XX {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*p) + (r)) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/swap.rs b/tests/unit/out/unsafe/swap.rs
index 08bfb83ca..d3590379e 100644
--- a/tests/unit/out/unsafe/swap.rs
+++ b/tests/unit/out/unsafe/swap.rs
@@ -21,6 +21,7 @@ pub unsafe fn swap_by_ref_2(a: *mut i32, b: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((c) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/swap_extended.rs b/tests/unit/out/unsafe/swap_extended.rs
index 8e7a8fd4f..136876b83 100644
--- a/tests/unit/out/unsafe/swap_extended.rs
+++ b/tests/unit/out/unsafe/swap_extended.rs
@@ -21,6 +21,7 @@ pub unsafe fn swap_by_ref_2(a: *mut i32, b: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -157,3 +158,4 @@ unsafe fn main_0() -> i32 {
     assert!(((c) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_basic.rs b/tests/unit/out/unsafe/switch_basic.rs
index 9a4bfbe96..0f558c099 100644
--- a/tests/unit/out/unsafe/switch_basic.rs
+++ b/tests/unit/out/unsafe/switch_basic.rs
@@ -34,6 +34,7 @@ pub unsafe fn basic_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { basic_0(99,) }) == (40)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs b/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs
index c63299fff..678d86150 100644
--- a/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs
+++ b/tests/unit/out/unsafe/switch_borrow_in_condition_and_in_body.rs
@@ -17,6 +17,7 @@ pub unsafe fn borrow_in_condition_and_in_body_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -25,3 +26,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { borrow_in_condition_and_in_body_0(1,) }) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_case_then_default.rs b/tests/unit/out/unsafe/switch_case_then_default.rs
index e3ef2e7d6..08c269c59 100644
--- a/tests/unit/out/unsafe/switch_case_then_default.rs
+++ b/tests/unit/out/unsafe/switch_case_then_default.rs
@@ -25,6 +25,7 @@ pub unsafe fn case_then_default_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { case_then_default_0(99,) }) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_cases_and_default_stacked.rs b/tests/unit/out/unsafe/switch_cases_and_default_stacked.rs
index 033c0f66a..115c7225f 100644
--- a/tests/unit/out/unsafe/switch_cases_and_default_stacked.rs
+++ b/tests/unit/out/unsafe/switch_cases_and_default_stacked.rs
@@ -25,6 +25,7 @@ pub unsafe fn cases_and_default_stacked_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { cases_and_default_stacked_0(99,) }) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_char.rs b/tests/unit/out/unsafe/switch_char.rs
index 9f1e06c19..77de6db9a 100644
--- a/tests/unit/out/unsafe/switch_char.rs
+++ b/tests/unit/out/unsafe/switch_char.rs
@@ -35,6 +35,7 @@ pub const Color_kGreen: Color = 1;
 pub const Color_kBlue: Color = 2;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -46,3 +47,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { switch_char_0(('z' as libc::c_char),) }) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_complex_cond.rs b/tests/unit/out/unsafe/switch_complex_cond.rs
index a5f76e98a..aea2e2a7c 100644
--- a/tests/unit/out/unsafe/switch_complex_cond.rs
+++ b/tests/unit/out/unsafe/switch_complex_cond.rs
@@ -28,6 +28,7 @@ pub unsafe fn switch_complex_cond_0(mut p: *mut i32, mut bias: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { switch_complex_cond_0((&mut p_val as *mut i32), 99,) }) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_compound_case_body.rs b/tests/unit/out/unsafe/switch_compound_case_body.rs
index 1b558c8b7..67941bb4c 100644
--- a/tests/unit/out/unsafe/switch_compound_case_body.rs
+++ b/tests/unit/out/unsafe/switch_compound_case_body.rs
@@ -32,6 +32,7 @@ pub unsafe fn compound_case_body_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { compound_case_body_0(9,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_continue_inside_switch.rs b/tests/unit/out/unsafe/switch_continue_inside_switch.rs
index 62bdb1c11..44c3d2387 100644
--- a/tests/unit/out/unsafe/switch_continue_inside_switch.rs
+++ b/tests/unit/out/unsafe/switch_continue_inside_switch.rs
@@ -30,6 +30,7 @@ pub unsafe fn continue_inside_switch_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { continue_inside_switch_0(6,) }) == ((((1) + (3)) + (5)) + ((3) * (1000)))));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_default_first.rs b/tests/unit/out/unsafe/switch_default_first.rs
index 28042b5ef..398319d9f 100644
--- a/tests/unit/out/unsafe/switch_default_first.rs
+++ b/tests/unit/out/unsafe/switch_default_first.rs
@@ -29,6 +29,7 @@ pub unsafe fn default_first_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { default_first_0(99,) }) == (7)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_default_middle.rs b/tests/unit/out/unsafe/switch_default_middle.rs
index 2b99f6658..46797d32d 100644
--- a/tests/unit/out/unsafe/switch_default_middle.rs
+++ b/tests/unit/out/unsafe/switch_default_middle.rs
@@ -29,6 +29,7 @@ pub unsafe fn default_middle_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { default_middle_0(99,) }) == (99)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_default_then_case.rs b/tests/unit/out/unsafe/switch_default_then_case.rs
index 9313072c6..60d5cc597 100644
--- a/tests/unit/out/unsafe/switch_default_then_case.rs
+++ b/tests/unit/out/unsafe/switch_default_then_case.rs
@@ -29,6 +29,7 @@ pub unsafe fn default_then_case_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { default_then_case_0(99,) }) == (77)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_empty_case_with_break.rs b/tests/unit/out/unsafe/switch_empty_case_with_break.rs
index ea1e1ec81..1eb09be3f 100644
--- a/tests/unit/out/unsafe/switch_empty_case_with_break.rs
+++ b/tests/unit/out/unsafe/switch_empty_case_with_break.rs
@@ -28,6 +28,7 @@ pub unsafe fn empty_case_with_break_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { empty_case_with_break_0(9,) }) == (9)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_empty_switch.rs b/tests/unit/out/unsafe/switch_empty_switch.rs
index 1816a14f2..f4d6c6bbe 100644
--- a/tests/unit/out/unsafe/switch_empty_switch.rs
+++ b/tests/unit/out/unsafe/switch_empty_switch.rs
@@ -17,6 +17,7 @@ pub unsafe fn empty_switch_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -24,3 +25,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { empty_switch_0(5,) }) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_enum.rs b/tests/unit/out/unsafe/switch_enum.rs
index 2394c4eb6..3ce434c11 100644
--- a/tests/unit/out/unsafe/switch_enum.rs
+++ b/tests/unit/out/unsafe/switch_enum.rs
@@ -30,6 +30,7 @@ pub unsafe fn switch_enum_0(mut c: Color) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { switch_enum_0(Color_kBlue,) }) == (30)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_fallthrough_chain.rs b/tests/unit/out/unsafe/switch_fallthrough_chain.rs
index 8ed878c47..06da4ef96 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_chain.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_chain.rs
@@ -31,6 +31,7 @@ pub unsafe fn fallthrough_chain_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { fallthrough_chain_0(99,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_fallthrough_default.rs b/tests/unit/out/unsafe/switch_fallthrough_default.rs
index 3bdaf74f3..1c36ac688 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_default.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_default.rs
@@ -24,6 +24,7 @@ pub unsafe fn fallthrough_default_0(mut x: i32, mut flag: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -33,3 +34,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { fallthrough_default_0(99, 0,) }) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_fallthrough_into_block.rs b/tests/unit/out/unsafe/switch_fallthrough_into_block.rs
index 32d5a46bd..122ab67d4 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_into_block.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_into_block.rs
@@ -28,6 +28,7 @@ pub unsafe fn fallthrough_into_block_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { fallthrough_into_block_0(99,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_fallthrough_one.rs b/tests/unit/out/unsafe/switch_fallthrough_one.rs
index a61417c2c..bb967905b 100644
--- a/tests/unit/out/unsafe/switch_fallthrough_one.rs
+++ b/tests/unit/out/unsafe/switch_fallthrough_one.rs
@@ -25,6 +25,7 @@ pub unsafe fn fallthrough_one_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { fallthrough_one_0(99,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_for_in_switch_break.rs b/tests/unit/out/unsafe/switch_for_in_switch_break.rs
index ef2314353..c04b58077 100644
--- a/tests/unit/out/unsafe/switch_for_in_switch_break.rs
+++ b/tests/unit/out/unsafe/switch_for_in_switch_break.rs
@@ -33,6 +33,7 @@ pub unsafe fn for_in_switch_break_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { for_in_switch_break_0(99,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_for_in_switch_continue.rs b/tests/unit/out/unsafe/switch_for_in_switch_continue.rs
index dfa7c04b7..675caa31e 100644
--- a/tests/unit/out/unsafe/switch_for_in_switch_continue.rs
+++ b/tests/unit/out/unsafe/switch_for_in_switch_continue.rs
@@ -33,6 +33,7 @@ pub unsafe fn for_in_switch_continue_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { for_in_switch_continue_0(99,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_for_switch_for_break.rs b/tests/unit/out/unsafe/switch_for_switch_for_break.rs
index 57082b04f..3a371cb2f 100644
--- a/tests/unit/out/unsafe/switch_for_switch_for_break.rs
+++ b/tests/unit/out/unsafe/switch_for_switch_for_break.rs
@@ -37,6 +37,7 @@ pub unsafe fn for_switch_for_break_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { for_switch_for_break_0(3,) }) == (122)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_in_dowhile.rs b/tests/unit/out/unsafe/switch_in_dowhile.rs
index aab80da64..777090766 100644
--- a/tests/unit/out/unsafe/switch_in_dowhile.rs
+++ b/tests/unit/out/unsafe/switch_in_dowhile.rs
@@ -35,6 +35,7 @@ pub unsafe fn switch_in_dowhile_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { switch_in_dowhile_0(3,) }) == (((1) + (10)) + (100))));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_in_loop.rs b/tests/unit/out/unsafe/switch_in_loop.rs
index 21d410611..5ce92ee23 100644
--- a/tests/unit/out/unsafe/switch_in_loop.rs
+++ b/tests/unit/out/unsafe/switch_in_loop.rs
@@ -34,6 +34,7 @@ pub unsafe fn switch_in_loop_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { switch_in_loop_0(6,) }) == (72)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_mixed_literal_cases.rs b/tests/unit/out/unsafe/switch_mixed_literal_cases.rs
index 1aa94a173..9c7945c7a 100644
--- a/tests/unit/out/unsafe/switch_mixed_literal_cases.rs
+++ b/tests/unit/out/unsafe/switch_mixed_literal_cases.rs
@@ -31,6 +31,7 @@ pub unsafe fn mixed_literal_cases_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { mixed_literal_cases_0(7,) }) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_mixed_return_break.rs b/tests/unit/out/unsafe/switch_mixed_return_break.rs
index ee451f6c0..a0c0e5285 100644
--- a/tests/unit/out/unsafe/switch_mixed_return_break.rs
+++ b/tests/unit/out/unsafe/switch_mixed_return_break.rs
@@ -31,6 +31,7 @@ pub unsafe fn mixed_return_break_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { mixed_return_break_0(99,) }) == (99)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_nested.rs b/tests/unit/out/unsafe/switch_nested.rs
index fa89c0a2c..18163180c 100644
--- a/tests/unit/out/unsafe/switch_nested.rs
+++ b/tests/unit/out/unsafe/switch_nested.rs
@@ -46,6 +46,7 @@ pub unsafe fn nested_0(mut a: i32, mut b: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { nested_0(3, 3,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_no_default.rs b/tests/unit/out/unsafe/switch_no_default.rs
index abc23d709..4f4f05f63 100644
--- a/tests/unit/out/unsafe/switch_no_default.rs
+++ b/tests/unit/out/unsafe/switch_no_default.rs
@@ -26,6 +26,7 @@ pub unsafe fn no_default_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { no_default_0(42,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_on_assignment.rs b/tests/unit/out/unsafe/switch_on_assignment.rs
index 5dd1b505b..ad726818c 100644
--- a/tests/unit/out/unsafe/switch_on_assignment.rs
+++ b/tests/unit/out/unsafe/switch_on_assignment.rs
@@ -33,6 +33,7 @@ pub unsafe fn switch_on_assignment_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { switch_on_assignment_0(9,) }) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_on_call.rs b/tests/unit/out/unsafe/switch_on_call.rs
index 633fb14cc..af59fb938 100644
--- a/tests/unit/out/unsafe/switch_on_call.rs
+++ b/tests/unit/out/unsafe/switch_on_call.rs
@@ -31,6 +31,7 @@ pub unsafe fn switch_on_call_1(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { switch_on_call_1(99,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_only_default.rs b/tests/unit/out/unsafe/switch_only_default.rs
index bd23bb445..37631fb3f 100644
--- a/tests/unit/out/unsafe/switch_only_default.rs
+++ b/tests/unit/out/unsafe/switch_only_default.rs
@@ -21,6 +21,7 @@ pub unsafe fn only_default_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { only_default_0(1,) }) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_stacked.rs b/tests/unit/out/unsafe/switch_stacked.rs
index eac997bf7..c6ad5c1da 100644
--- a/tests/unit/out/unsafe/switch_stacked.rs
+++ b/tests/unit/out/unsafe/switch_stacked.rs
@@ -29,6 +29,7 @@ pub unsafe fn stacked_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { stacked_0(9,) }) == (300)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_stacked_block.rs b/tests/unit/out/unsafe/switch_stacked_block.rs
index 7e6db9964..56a0b9797 100644
--- a/tests/unit/out/unsafe/switch_stacked_block.rs
+++ b/tests/unit/out/unsafe/switch_stacked_block.rs
@@ -26,6 +26,7 @@ pub unsafe fn stacked_block_0(mut x: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -34,3 +35,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { stacked_block_0(9,) }) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs b/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs
index 183bd8936..2ed5d5206 100644
--- a/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs
+++ b/tests/unit/out/unsafe/switch_stacked_with_inner_fallthrough.rs
@@ -24,6 +24,7 @@ pub unsafe fn stacked_with_inner_fallthrough_0(mut x: i32, mut flag: i32) -> i32
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -33,3 +34,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { stacked_with_inner_fallthrough_0(99, 0,) }) == (999)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/switch_while_in_switch_break.rs b/tests/unit/out/unsafe/switch_while_in_switch_break.rs
index 36c4a6643..7ea9c2a56 100644
--- a/tests/unit/out/unsafe/switch_while_in_switch_break.rs
+++ b/tests/unit/out/unsafe/switch_while_in_switch_break.rs
@@ -33,6 +33,7 @@ pub unsafe fn while_in_switch_break_0(mut n: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -41,3 +42,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { while_in_switch_break_0(99,) }) == (-1_i32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/sys_stat.rs b/tests/unit/out/unsafe/sys_stat.rs
index 2417229d3..4c46af409 100644
--- a/tests/unit/out/unsafe/sys_stat.rs
+++ b/tests/unit/out/unsafe/sys_stat.rs
@@ -36,6 +36,7 @@ pub unsafe fn test_fstat_1() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_fstat_1() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/sys_time.rs b/tests/unit/out/unsafe/sys_time.rs
index 2bcfd93c8..ee553db9f 100644
--- a/tests/unit/out/unsafe/sys_time.rs
+++ b/tests/unit/out/unsafe/sys_time.rs
@@ -166,6 +166,7 @@ pub unsafe fn test_strftime_5() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -176,3 +177,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_strftime_5() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/tag_vs_identifier_collision.rs b/tests/unit/out/unsafe/tag_vs_identifier_collision.rs
index 6a634ad55..ab8ba8bcb 100644
--- a/tests/unit/out/unsafe/tag_vs_identifier_collision.rs
+++ b/tests/unit/out/unsafe/tag_vs_identifier_collision.rs
@@ -67,6 +67,7 @@ pub unsafe fn is_active_0(mut w: *mut widget) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -101,3 +102,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((w.id) == (7)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/template_pack.rs b/tests/unit/out/unsafe/template_pack.rs
index 6fcd77359..a5961b16d 100644
--- a/tests/unit/out/unsafe/template_pack.rs
+++ b/tests/unit/out/unsafe/template_pack.rs
@@ -43,6 +43,7 @@ pub unsafe fn sizeof_pack_9(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -58,3 +59,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { sizeof_pack_9(1, 2, 3, 4,) }) == (4)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/templates.rs b/tests/unit/out/unsafe/templates.rs
index 2fd9061c6..f9300b546 100644
--- a/tests/unit/out/unsafe/templates.rs
+++ b/tests/unit/out/unsafe/templates.rs
@@ -26,6 +26,7 @@ pub unsafe fn func_5(mut x1: f64, mut x2: i32, mut x3: f64) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -42,3 +43,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/termios.rs b/tests/unit/out/unsafe/termios.rs
index 459d480d3..1f27365d7 100644
--- a/tests/unit/out/unsafe/termios.rs
+++ b/tests/unit/out/unsafe/termios.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((libc::unlink(path)) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/this.rs b/tests/unit/out/unsafe/this.rs
index 124382998..bb17e65b9 100644
--- a/tests/unit/out/unsafe/this.rs
+++ b/tests/unit/out/unsafe/this.rs
@@ -113,6 +113,7 @@ impl D {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -185,3 +186,4 @@ unsafe fn main_0() -> i32 {
     assert!((u1.self__).is_null());
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/typedef-anon-struct.rs b/tests/unit/out/unsafe/typedef-anon-struct.rs
index cac2ea342..44d6a9cfb 100644
--- a/tests/unit/out/unsafe/typedef-anon-struct.rs
+++ b/tests/unit/out/unsafe/typedef-anon-struct.rs
@@ -19,6 +19,7 @@ pub struct Outer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -36,3 +37,4 @@ unsafe fn main_0() -> i32 {
     assert!(((o.runs[(0_usize)].num_extra_zero_runs) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/types.rs b/tests/unit/out/unsafe/types.rs
index b97e59537..1d6da6bb0 100644
--- a/tests/unit/out/unsafe/types.rs
+++ b/tests/unit/out/unsafe/types.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -45,3 +46,4 @@ unsafe fn main_0() -> i32 {
     assert!((<*mut ::libc::c_void>::default()).is_null());
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unary.rs b/tests/unit/out/unsafe/unary.rs
index 7d9cddb42..8bb059fdb 100644
--- a/tests/unit/out/unsafe/unary.rs
+++ b/tests/unit/out/unsafe/unary.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -28,3 +29,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((out.postfix_inc()) + (x2)) + (x3)) == (19)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unary_expr_or_type_trait.rs b/tests/unit/out/unsafe/unary_expr_or_type_trait.rs
index d00570c35..f040def13 100644
--- a/tests/unit/out/unsafe/unary_expr_or_type_trait.rs
+++ b/tests/unit/out/unsafe/unary_expr_or_type_trait.rs
@@ -20,6 +20,7 @@ pub unsafe fn pack_size_1(mut args_0: i32, mut args_1: f64) -> u64 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -40,3 +41,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { pack_size_1(1, 2.0E+0,) }) == (4_u64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unconst.rs b/tests/unit/out/unsafe/unconst.rs
index 13041748e..7d914b094 100644
--- a/tests/unit/out/unsafe/unconst.rs
+++ b/tests/unit/out/unsafe/unconst.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(((p) == ((q).cast_const())));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_addrof_external.rs b/tests/unit/out/unsafe/union_addrof_external.rs
index b4cbb9f98..830617b75 100644
--- a/tests/unit/out/unsafe/union_addrof_external.rs
+++ b/tests/unit/out/unsafe/union_addrof_external.rs
@@ -71,6 +71,7 @@ pub unsafe fn fill_1(mut out: *mut ::libc::c_void, mut cap: usize) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -104,3 +105,4 @@ unsafe fn main_0() -> i32 {
     assert!((((((c.view.raw_[(3) as usize] as u8) as i32) == (80)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_basic.rs b/tests/unit/out/unsafe/union_basic.rs
index 81e82df3c..4f84ada02 100644
--- a/tests/unit/out/unsafe/union_basic.rs
+++ b/tests/unit/out/unsafe/union_basic.rs
@@ -19,6 +19,7 @@ impl Default for basic {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((u.f) == (3.140000105E+0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_cross_arm_cast.rs b/tests/unit/out/unsafe/union_cross_arm_cast.rs
index eaf74bb9e..35e1b665a 100644
--- a/tests/unit/out/unsafe/union_cross_arm_cast.rs
+++ b/tests/unit/out/unsafe/union_cross_arm_cast.rs
@@ -60,6 +60,7 @@ pub struct Container {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -92,3 +93,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_field_alignment.rs b/tests/unit/out/unsafe/union_field_alignment.rs
index 15b8df188..580c093ba 100644
--- a/tests/unit/out/unsafe/union_field_alignment.rs
+++ b/tests/unit/out/unsafe/union_field_alignment.rs
@@ -25,6 +25,7 @@ pub struct node {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!((((((*n.x.bytes.as_mut_ptr().add((0) as usize)) as i32) == (171)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_flex_array_member.rs b/tests/unit/out/unsafe/union_flex_array_member.rs
index 5536656df..e13a8cd12 100644
--- a/tests/unit/out/unsafe/union_flex_array_member.rs
+++ b/tests/unit/out/unsafe/union_flex_array_member.rs
@@ -26,6 +26,7 @@ pub struct node {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -61,3 +62,4 @@ unsafe fn main_0() -> i32 {
     libcc2rs::free_unsafe((n as *mut node as *mut ::libc::c_void));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_memset_memcpy.rs b/tests/unit/out/unsafe/union_memset_memcpy.rs
index c48017413..b8c6dac03 100644
--- a/tests/unit/out/unsafe/union_memset_memcpy.rs
+++ b/tests/unit/out/unsafe/union_memset_memcpy.rs
@@ -57,6 +57,7 @@ pub struct Container {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -116,3 +117,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((c.view.b.code as i32) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_nested.rs b/tests/unit/out/unsafe/union_nested.rs
index 4d16a9b02..0e59f04cf 100644
--- a/tests/unit/out/unsafe/union_nested.rs
+++ b/tests/unit/out/unsafe/union_nested.rs
@@ -58,6 +58,7 @@ pub struct Outer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -81,3 +82,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((ex.body.nested.view.h.code as i32) == (2)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_pointer_pun_address.rs b/tests/unit/out/unsafe/union_pointer_pun_address.rs
index 858e04b89..d3e84bd06 100644
--- a/tests/unit/out/unsafe/union_pointer_pun_address.rs
+++ b/tests/unit/out/unsafe/union_pointer_pun_address.rs
@@ -19,6 +19,7 @@ pub struct node_b {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -45,3 +46,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_pointer_pun_writethrough.rs b/tests/unit/out/unsafe/union_pointer_pun_writethrough.rs
index 172ad3965..c258dd435 100644
--- a/tests/unit/out/unsafe/union_pointer_pun_writethrough.rs
+++ b/tests/unit/out/unsafe/union_pointer_pun_writethrough.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((x) == (42_i64)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_struct_dual_use.rs b/tests/unit/out/unsafe/union_struct_dual_use.rs
index c392b62c4..27a8df55c 100644
--- a/tests/unit/out/unsafe/union_struct_dual_use.rs
+++ b/tests/unit/out/unsafe/union_struct_dual_use.rs
@@ -33,6 +33,7 @@ pub struct Outer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,4 @@ unsafe fn main_0() -> i32 {
     assert!((((((outer.u.raw_[(4) as usize] as u8) as i32) == (4)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_tagged_many_arms.rs b/tests/unit/out/unsafe/union_tagged_many_arms.rs
index ac86b172e..ca262ab1c 100644
--- a/tests/unit/out/unsafe/union_tagged_many_arms.rs
+++ b/tests/unit/out/unsafe/union_tagged_many_arms.rs
@@ -34,6 +34,7 @@ pub struct Slot {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -65,3 +66,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_tagged_simple.rs b/tests/unit/out/unsafe/union_tagged_simple.rs
index 29fbc961b..f3713395d 100644
--- a/tests/unit/out/unsafe/union_tagged_simple.rs
+++ b/tests/unit/out/unsafe/union_tagged_simple.rs
@@ -29,6 +29,7 @@ pub struct Event {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -51,3 +52,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_tagged_struct_arms.rs b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
index 8ae914546..8a86d68b0 100644
--- a/tests/unit/out/unsafe/union_tagged_struct_arms.rs
+++ b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
@@ -55,6 +55,7 @@ pub struct Branch {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -99,3 +100,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((p_integers.v.integers.width) == (3)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
index d227c9fdf..c29a85870 100644
--- a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
+++ b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
@@ -51,6 +51,7 @@ pub unsafe fn write_count_1(mut s: *mut Sink, mut count: i64) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -73,3 +74,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((buf16 as i32) == (4660)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr.rs b/tests/unit/out/unsafe/unique_ptr.rs
index 3c79812b0..05a3be1a0 100644
--- a/tests/unit/out/unsafe/unique_ptr.rs
+++ b/tests/unit/out/unsafe/unique_ptr.rs
@@ -144,6 +144,7 @@ pub unsafe fn RndStuff_2() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -154,3 +155,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { Consume_1(safe_ptr.take(),) }) == (60)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr_const_deref.rs b/tests/unit/out/unsafe/unique_ptr_const_deref.rs
index 2de998939..3f2628d94 100644
--- a/tests/unit/out/unsafe/unique_ptr_const_deref.rs
+++ b/tests/unit/out/unsafe/unique_ptr_const_deref.rs
@@ -23,6 +23,7 @@ pub unsafe fn write_val_1(mut h: *const Holder, mut v: i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -33,3 +34,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { read_val_0((&mut h as *mut Holder).cast_const(),) }) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr_deref_ops.rs b/tests/unit/out/unsafe/unique_ptr_deref_ops.rs
index f6a6456c7..3f0842102 100644
--- a/tests/unit/out/unsafe/unique_ptr_deref_ops.rs
+++ b/tests/unit/out/unsafe/unique_ptr_deref_ops.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((sum) == (25)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr_nested.rs b/tests/unit/out/unsafe/unique_ptr_nested.rs
index 02c01c143..1b1bccca7 100644
--- a/tests/unit/out/unsafe/unique_ptr_nested.rs
+++ b/tests/unit/out/unsafe/unique_ptr_nested.rs
@@ -19,6 +19,7 @@ pub struct Outer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!((((sum) + (*b.as_deref_mut().unwrap())) == (135)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr_small.rs b/tests/unit/out/unsafe/unique_ptr_small.rs
index 9abcb1518..8d7295a6b 100644
--- a/tests/unit/out/unsafe/unique_ptr_small.rs
+++ b/tests/unit/out/unsafe/unique_ptr_small.rs
@@ -12,6 +12,7 @@ pub unsafe fn change_0(n: *mut Option<Box<i32>>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*n.as_deref_mut().unwrap()) == (20)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr_struct.rs b/tests/unit/out/unsafe/unique_ptr_struct.rs
index cfa481494..a17a15df1 100644
--- a/tests/unit/out/unsafe/unique_ptr_struct.rs
+++ b/tests/unit/out/unsafe/unique_ptr_struct.rs
@@ -17,6 +17,7 @@ pub unsafe fn sum_0(mut p: Point) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!(((s) == (30)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unistd.rs b/tests/unit/out/unsafe/unistd.rs
index 4d15e652d..a8d036a32 100644
--- a/tests/unit/out/unsafe/unistd.rs
+++ b/tests/unit/out/unsafe/unistd.rs
@@ -292,6 +292,7 @@ pub unsafe fn test_gethostname_11() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -310,3 +311,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_gethostname_11() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unsigned.rs b/tests/unit/out/unsafe/unsigned.rs
index 3fcc074c0..2535fd131 100644
--- a/tests/unit/out/unsafe/unsigned.rs
+++ b/tests/unit/out/unsafe/unsigned.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     assert!(((a) == (255)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/user_defined_same_as_libc.rs b/tests/unit/out/unsafe/user_defined_same_as_libc.rs
index 6d5529008..f4ee54c39 100644
--- a/tests/unit/out/unsafe/user_defined_same_as_libc.rs
+++ b/tests/unit/out/unsafe/user_defined_same_as_libc.rs
@@ -16,6 +16,7 @@ pub unsafe fn fopen_0(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((fp).is_null()) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_chain.rs b/tests/unit/out/unsafe/va_arg_chain.rs
index 72694c87f..ac557ee28 100644
--- a/tests/unit/out/unsafe/va_arg_chain.rs
+++ b/tests/unit/out/unsafe/va_arg_chain.rs
@@ -25,6 +25,7 @@ pub unsafe fn top_level_2(mut n: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_concat.rs b/tests/unit/out/unsafe/va_arg_concat.rs
index 37a60e624..f225947b0 100644
--- a/tests/unit/out/unsafe/va_arg_concat.rs
+++ b/tests/unit/out/unsafe/va_arg_concat.rs
@@ -23,6 +23,7 @@ pub unsafe fn sum_ints_0(mut first: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_conditional.rs b/tests/unit/out/unsafe/va_arg_conditional.rs
index 1d302595d..bb3e4429b 100644
--- a/tests/unit/out/unsafe/va_arg_conditional.rs
+++ b/tests/unit/out/unsafe/va_arg_conditional.rs
@@ -21,6 +21,7 @@ pub unsafe fn conditional_log_0(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_copy.rs b/tests/unit/out/unsafe/va_arg_copy.rs
index 6ddd53ea1..d3a418112 100644
--- a/tests/unit/out/unsafe/va_arg_copy.rs
+++ b/tests/unit/out/unsafe/va_arg_copy.rs
@@ -28,6 +28,7 @@ pub unsafe fn sum_with_copy_0(mut count: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_fn_ptr.rs b/tests/unit/out/unsafe/va_arg_fn_ptr.rs
index a02eea3d0..7c749c4c7 100644
--- a/tests/unit/out/unsafe/va_arg_fn_ptr.rs
+++ b/tests/unit/out/unsafe/va_arg_fn_ptr.rs
@@ -47,6 +47,7 @@ pub unsafe fn not_supported_5(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -101,3 +102,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_forward.rs b/tests/unit/out/unsafe/va_arg_forward.rs
index 802489395..571764b8f 100644
--- a/tests/unit/out/unsafe/va_arg_forward.rs
+++ b/tests/unit/out/unsafe/va_arg_forward.rs
@@ -23,6 +23,7 @@ pub unsafe fn outer_1(mut count: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -35,3 +36,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((unsafe { outer_1(0, &[]) }) == (0)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_mixed_int_ptr.rs b/tests/unit/out/unsafe/va_arg_mixed_int_ptr.rs
index bd810d5f7..97e92cffa 100644
--- a/tests/unit/out/unsafe/va_arg_mixed_int_ptr.rs
+++ b/tests/unit/out/unsafe/va_arg_mixed_int_ptr.rs
@@ -25,6 +25,7 @@ pub unsafe fn mixed_args_0(mut count: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -59,3 +60,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_mixed_types.rs b/tests/unit/out/unsafe/va_arg_mixed_types.rs
index fa4a9d2cc..f9130e37c 100644
--- a/tests/unit/out/unsafe/va_arg_mixed_types.rs
+++ b/tests/unit/out/unsafe/va_arg_mixed_types.rs
@@ -27,6 +27,7 @@ pub unsafe fn sum_mixed_0(mut count: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -59,3 +60,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs b/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs
index e77a34b3d..65c520839 100644
--- a/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs
+++ b/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs
@@ -53,6 +53,7 @@ pub unsafe fn dispatch_0(mut option: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -105,3 +106,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((outp).is_null()) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_null_int_ptr.rs b/tests/unit/out/unsafe/va_arg_null_int_ptr.rs
index b9bd236d1..9c8db2eff 100644
--- a/tests/unit/out/unsafe/va_arg_null_int_ptr.rs
+++ b/tests/unit/out/unsafe/va_arg_null_int_ptr.rs
@@ -23,6 +23,7 @@ pub unsafe fn first_nonnull_0(mut count: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -60,3 +61,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_printf.rs b/tests/unit/out/unsafe/va_arg_printf.rs
index e76041db9..052e4ae90 100644
--- a/tests/unit/out/unsafe/va_arg_printf.rs
+++ b/tests/unit/out/unsafe/va_arg_printf.rs
@@ -25,6 +25,7 @@ pub unsafe fn lenf_2(mut fmt: *const libc::c_char, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -69,3 +70,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_promotion.rs b/tests/unit/out/unsafe/va_arg_promotion.rs
index cda547f98..97cc97480 100644
--- a/tests/unit/out/unsafe/va_arg_promotion.rs
+++ b/tests/unit/out/unsafe/va_arg_promotion.rs
@@ -19,6 +19,7 @@ pub unsafe fn test_promotions_0(mut count: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_snprintf.rs b/tests/unit/out/unsafe/va_arg_snprintf.rs
index f9ea75f08..26b78730a 100644
--- a/tests/unit/out/unsafe/va_arg_snprintf.rs
+++ b/tests/unit/out/unsafe/va_arg_snprintf.rs
@@ -20,6 +20,7 @@ pub unsafe fn extract_first_0(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -51,3 +52,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((buf[(0) as usize] as i32) == ('A' as i32)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_struct_ctx.rs b/tests/unit/out/unsafe/va_arg_struct_ctx.rs
index 176dc3523..23f38305e 100644
--- a/tests/unit/out/unsafe/va_arg_struct_ctx.rs
+++ b/tests/unit/out/unsafe/va_arg_struct_ctx.rs
@@ -21,6 +21,7 @@ pub unsafe fn set_error_0(mut ctx: *mut context, mut fmt: *const libc::c_char, _
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -47,3 +48,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((ctx.last_error) == (42)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_two_passes.rs b/tests/unit/out/unsafe/va_arg_two_passes.rs
index bfbaf9878..0b9152996 100644
--- a/tests/unit/out/unsafe/va_arg_two_passes.rs
+++ b/tests/unit/out/unsafe/va_arg_two_passes.rs
@@ -33,6 +33,7 @@ pub unsafe fn sum_then_product_0(mut first: i32, __args: &[VaArg]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/va_arg_void_ptr.rs b/tests/unit/out/unsafe/va_arg_void_ptr.rs
index 2f0fef0e9..a68910335 100644
--- a/tests/unit/out/unsafe/va_arg_void_ptr.rs
+++ b/tests/unit/out/unsafe/va_arg_void_ptr.rs
@@ -40,6 +40,7 @@ pub unsafe fn registry_update_0(mut r: *mut registry, mut field: field, __args:
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -74,3 +75,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((r.level) == (5_i64)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector.rs b/tests/unit/out/unsafe/vector.rs
index ea219b2ea..559c9d14c 100644
--- a/tests/unit/out/unsafe/vector.rs
+++ b/tests/unit/out/unsafe/vector.rs
@@ -9,6 +9,7 @@ use std::rc::Rc;
 pub unsafe fn copy_0(mut copy_vector: Vec<i32>) {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -164,3 +165,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector2.rs b/tests/unit/out/unsafe/vector2.rs
index b23aebcdd..d353e0a56 100644
--- a/tests/unit/out/unsafe/vector2.rs
+++ b/tests/unit/out/unsafe/vector2.rs
@@ -33,6 +33,7 @@ pub unsafe fn fn_0(v: *mut Vec<i32>, mut v3: Vec<i32>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -47,3 +48,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { fn_0(&mut v as *mut Vec<i32>, v2.clone()) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs
index d9573cb01..e8c8a165f 100644
--- a/tests/unit/out/unsafe/vector3.rs
+++ b/tests/unit/out/unsafe/vector3.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -48,3 +49,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector_addr_of_back.rs b/tests/unit/out/unsafe/vector_addr_of_back.rs
index 03296fd9f..b07ee1ae0 100644
--- a/tests/unit/out/unsafe/vector_addr_of_back.rs
+++ b/tests/unit/out/unsafe/vector_addr_of_back.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -22,3 +23,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*(sink).cast_const()).len()) == (0_usize)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector_iter_range_ctor.rs b/tests/unit/out/unsafe/vector_iter_range_ctor.rs
index 73d470f86..a9c316f52 100644
--- a/tests/unit/out/unsafe/vector_iter_range_ctor.rs
+++ b/tests/unit/out/unsafe/vector_iter_range_ctor.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -69,3 +70,4 @@ unsafe fn main_0() -> i32 {
     assert!(((v5[(0_usize)] as i32) == (10)) && ((v5[(4_usize)] as i32) == (50)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs
index 44d0acdb4..840ddb71a 100644
--- a/tests/unit/out/unsafe/vector_with_allocator.rs
+++ b/tests/unit/out/unsafe/vector_with_allocator.rs
@@ -58,6 +58,7 @@ pub unsafe fn fn_1(v: *mut Vec<i32>, mut v3: Vec<i32>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -247,3 +248,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/void_cast.rs b/tests/unit/out/unsafe/void_cast.rs
index 79e223e59..550a6200d 100644
--- a/tests/unit/out/unsafe/void_cast.rs
+++ b/tests/unit/out/unsafe/void_cast.rs
@@ -41,6 +41,7 @@ pub unsafe fn unused_noncopyable_param_5(x: *const NonCopyable) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -113,3 +114,6 @@ unsafe fn main_0() -> i32 {
     assert!(((*g.value.as_deref_mut().unwrap()) == (9)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const side_effect_counter_3);
+}
diff --git a/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs b/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs
index 57fadd9c7..c798f66f3 100644
--- a/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs
+++ b/tests/unit/out/unsafe/void_ptr_implicit_conversion.rs
@@ -13,6 +13,7 @@ pub unsafe fn bump_0(mut arg: *mut ::libc::c_void) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -27,3 +28,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((value) == (7)) as i32) != 0));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/void_return.rs b/tests/unit/out/unsafe/void_return.rs
index bc5e4b47c..ce31332a0 100644
--- a/tests/unit/out/unsafe/void_return.rs
+++ b/tests/unit/out/unsafe/void_return.rs
@@ -15,6 +15,7 @@ pub unsafe fn f1_0(mut first: *mut i32, mut last: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -27,3 +28,4 @@ unsafe fn main_0() -> i32 {
     });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/void_round_trip.rs b/tests/unit/out/unsafe/void_round_trip.rs
index f4e99e2d0..dd9ae7041 100644
--- a/tests/unit/out/unsafe/void_round_trip.rs
+++ b/tests/unit/out/unsafe/void_round_trip.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/z_bit_cast.rs b/tests/unit/out/unsafe/z_bit_cast.rs
index 8ba0eea10..f23abe306 100644
--- a/tests/unit/out/unsafe/z_bit_cast.rs
+++ b/tests/unit/out/unsafe/z_bit_cast.rs
@@ -10,6 +10,7 @@ pub unsafe fn decay_cast_0(mut a1: *mut u32) {}
 pub unsafe fn bit_cast_1(mut p: *const ::libc::c_void) {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*(ptr as *mut u32).offset((0) as isize)) == (a1[(0) as usize])));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}

From 10a5051d2f809420aa877c5269a82b1996332cf6 Mon Sep 17 00:00:00 2001
From: Lucian Popescu <lucian.popescu@tecnico.ulisboa.pt>
Date: Tue, 15 Sep 2026 16:38:45 +0100
Subject: [PATCH 6/9] Update tests

---
 .../out/unsafe/dangling-prvalue-as-lvalue.rs  |  2 +
 tests/ub/out/unsafe/ub1.rs                    |  2 +
 tests/ub/out/unsafe/ub4.rs                    |  2 +
 tests/ub/out/unsafe/ub5.rs                    |  2 +
 tests/ub/out/unsafe/ub6.rs                    |  2 +
 tests/unit/out/refcount/12_test.rs            |  2 +
 tests/unit/out/refcount/auto.rs               |  2 +
 tests/unit/out/refcount/clone_vs_move.rs      |  2 +
 tests/unit/out/refcount/complex_function.rs   |  2 +
 .../unit/out/refcount/compound_assign_ref.rs  |  2 +
 tests/unit/out/refcount/cstring.rs            |  2 +
 tests/unit/out/refcount/errno.rs              |  2 +
 tests/unit/out/refcount/fcntl.rs              |  2 +
 tests/unit/out/refcount/fd_io.rs              |  2 +
 tests/unit/out/refcount/find.rs               |  2 +
 .../out/refcount/fn_ptr_stdlib_compare.rs     |  2 +
 tests/unit/out/refcount/foreach.rs            |  2 +
 .../refcount/foreach_disjoint_field_borrow.rs |  2 +
 tests/unit/out/refcount/foreach_double.rs     |  2 +
 tests/unit/out/refcount/foreach_map.rs        |  2 +
 tests/unit/out/refcount/foreach_mut.rs        |  2 +
 tests/unit/out/refcount/ifaddrs.rs            |  2 +
 tests/unit/out/refcount/inet_pton_ntop.rs     |  2 +
 tests/unit/out/refcount/iterators.rs          |  2 +
 tests/unit/out/refcount/lseek_ftruncate.rs    |  2 +
 tests/unit/out/refcount/map-reallocation.rs   |  2 +
 tests/unit/out/refcount/map.rs                |  2 +
 tests/unit/out/refcount/memcpy_overlap.rs     |  2 +
 .../unit/out/refcount/memcpy_struct_bytes.rs  |  2 +
 .../unit/out/refcount/memcpy_struct_struct.rs |  2 +
 tests/unit/out/refcount/memset.rs             |  2 +
 tests/unit/out/refcount/netdb.rs              |  2 +
 tests/unit/out/refcount/new_alloc_array.rs    |  2 +
 tests/unit/out/refcount/operator_traits.rs    |  2 +
 tests/unit/out/refcount/pipe_io.rs            |  2 +
 tests/unit/out/refcount/pointers.rs           |  2 +
 tests/unit/out/refcount/poll.rs               |  2 +
 tests/unit/out/refcount/push_emplace_back.rs  |  2 +
 tests/unit/out/refcount/pwd.rs                |  2 +
 .../refcount/redundant_copy_in_conversion.rs  |  2 +
 tests/unit/out/refcount/reference_wrapper.rs  |  2 +
 tests/unit/out/refcount/select.rs             |  2 +
 tests/unit/out/refcount/stdcopy.rs            |  2 +
 tests/unit/out/refcount/stdio_nofd.rs         |  2 +
 tests/unit/out/refcount/strdup.rs             |  2 +
 tests/unit/out/refcount/string_h.rs           |  2 +
 tests/unit/out/refcount/sys_time.rs           |  2 +
 .../out/refcount/union_addrof_external.rs     |  2 +
 .../unit/out/refcount/union_cross_arm_cast.rs |  2 +
 .../unit/out/refcount/union_memset_memcpy.rs  |  2 +
 tests/unit/out/refcount/union_nested.rs       |  2 +
 .../out/refcount/union_struct_dual_use.rs     |  2 +
 tests/unit/out/refcount/vector.rs             |  2 +
 tests/unit/out/refcount/vector3.rs            |  2 +
 .../out/refcount/vector_with_allocator.rs     |  2 +
 tests/unit/out/refcount/void_return.rs        |  2 +
 .../unit/out/unsafe/04_address_taken_array.rs |  2 +
 tests/unit/out/unsafe/09_references.rs        |  2 +
 tests/unit/out/unsafe/11_move.rs              |  2 +
 tests/unit/out/unsafe/13_testing.rs           |  2 +
 tests/unit/out/unsafe/alloc_array.rs          |  2 +
 tests/unit/out/unsafe/array_reference.rs      |  2 +
 tests/unit/out/unsafe/borrow_mut_opt.rs       |  2 +
 tests/unit/out/unsafe/class.rs                |  2 +
 tests/unit/out/unsafe/clone_vs_move.rs        |  2 +
 tests/unit/out/unsafe/complex_function.rs     |  2 +
 tests/unit/out/unsafe/copy_assign.rs          | 20 ++++---
 tests/unit/out/unsafe/copy_ctor.rs            | 22 ++++---
 tests/unit/out/unsafe/cout_alias.rs           |  2 +
 tests/unit/out/unsafe/doubly_linked_list.rs   |  2 +
 tests/unit/out/unsafe/exprs.rs                |  2 +
 tests/unit/out/unsafe/fatorial.rs             |  2 +
 tests/unit/out/unsafe/fft.rs                  |  2 +
 tests/unit/out/unsafe/foreach_double.rs       |  2 +
 tests/unit/out/unsafe/friend.rs               |  2 +
 tests/unit/out/unsafe/function_overloading.rs |  2 +
 .../unit/out/unsafe/global_non_const_init.rs  |  2 +-
 tests/unit/out/unsafe/huffman.rs              |  2 +
 tests/unit/out/unsafe/init.rs                 |  2 +
 tests/unit/out/unsafe/kruskal.rs              |  2 +
 tests/unit/out/unsafe/linked_list.rs          |  2 +
 tests/unit/out/unsafe/map.rs                  |  2 +
 tests/unit/out/unsafe/move_assign.rs          |  2 +
 tests/unit/out/unsafe/move_this.rs            |  2 +
 tests/unit/out/unsafe/new_array_var_size.rs   |  2 +
 .../out/unsafe/operator_arithmetic_free.rs    |  2 +
 .../out/unsafe/operator_arithmetic_member.rs  |  2 +
 .../unit/out/unsafe/operator_bitwise_free.rs  |  2 +
 .../out/unsafe/operator_bitwise_member.rs     |  2 +
 .../unsafe/operator_comparison_defaulted.rs   |  2 +
 .../out/unsafe/operator_comparison_free.rs    |  2 +
 .../out/unsafe/operator_comparison_member.rs  |  2 +
 .../out/unsafe/operator_comparison_mixed.rs   |  2 +
 .../unsafe/operator_comparison_noncopyable.rs |  2 +
 .../operator_compound_assignment_free.rs      |  2 +
 .../operator_compound_assignment_member.rs    |  2 +
 tests/unit/out/unsafe/operator_less_than.rs   |  2 +
 .../unit/out/unsafe/operator_logical_free.rs  |  2 +
 .../out/unsafe/operator_logical_member.rs     |  2 +
 .../unsafe/operator_member_pointer_free.rs    |  2 +
 .../unsafe/operator_member_pointer_member.rs  | 11 +++-
 tests/unit/out/unsafe/operator_other_free.rs  |  2 +
 .../unit/out/unsafe/operator_other_member.rs  |  2 +
 tests/unit/out/unsafe/operator_overloads.rs   |  2 +
 tests/unit/out/unsafe/operator_three_way.rs   |  2 +
 tests/unit/out/unsafe/pod.rs                  |  2 +
 tests/unit/out/unsafe/pointer_array.rs        |  2 +
 tests/unit/out/unsafe/printfs.rs              |  2 +
 tests/unit/out/unsafe/prvalue-as-lvalue.rs    |  2 +
 tests/unit/out/unsafe/random.rs               |  2 +
 tests/unit/out/unsafe/rebind.rs               |  2 +
 tests/unit/out/unsafe/ref_calls.rs            |  2 +
 tests/unit/out/unsafe/references.rs           |  2 +
 tests/unit/out/unsafe/references2.rs          |  2 +
 tests/unit/out/unsafe/refs_as_args.rs         |  2 +
 tests/unit/out/unsafe/rule_of_five.rs         | 59 +++++++++++++------
 tests/unit/out/unsafe/rule_of_three.rs        | 40 +++++++++----
 .../out/unsafe/split_binop_aliased_borrows.rs |  2 +
 tests/unit/out/unsafe/struct_ctor.rs          |  2 +
 tests/unit/out/unsafe/swap.rs                 |  2 +
 tests/unit/out/unsafe/swap_extended.rs        |  2 +
 tests/unit/out/unsafe/this.rs                 |  2 +
 tests/unit/out/unsafe/unique_ptr.rs           |  2 +
 tests/unit/out/unsafe/unique_ptr_small.rs     |  2 +
 tests/unit/out/unsafe/unistd.rs               |  2 +
 tests/unit/out/unsafe/vector2.rs              |  2 +
 .../unit/out/unsafe/vector_with_allocator.rs  |  2 +
 tests/unit/out/unsafe/void_cast.rs            | 21 ++++---
 128 files changed, 357 insertions(+), 60 deletions(-)

diff --git a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
index 32337b390..c8d8a40f6 100644
--- a/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
+++ b/tests/ub/out/unsafe/dangling-prvalue-as-lvalue.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(a: *const i32) -> *const i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     v.clear();
     return (*b);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub1.rs b/tests/ub/out/unsafe/ub1.rs
index 71faa394e..8cbe0ab66 100644
--- a/tests/ub/out/unsafe/ub1.rs
+++ b/tests/ub/out/unsafe/ub1.rs
@@ -13,6 +13,7 @@ pub unsafe fn dangling_0() -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     let x: *mut i32 = (unsafe { dangling_0() });
     return (*x);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub4.rs b/tests/ub/out/unsafe/ub4.rs
index 22d7d6cb7..6ef1a637f 100644
--- a/tests/ub/out/unsafe/ub4.rs
+++ b/tests/ub/out/unsafe/ub4.rs
@@ -11,6 +11,7 @@ pub unsafe fn smaller_0(x1: *mut i32, x2: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     }
     return (*out);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub5.rs b/tests/ub/out/unsafe/ub5.rs
index b3c322cfe..a41c2db7f 100644
--- a/tests/ub/out/unsafe/ub5.rs
+++ b/tests/ub/out/unsafe/ub5.rs
@@ -11,6 +11,7 @@ pub unsafe fn null_0(mut p: *mut *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     let r: *mut i32 = &mut (*p);
     return (*r);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/ub/out/unsafe/ub6.rs b/tests/ub/out/unsafe/ub6.rs
index 9bb09de2a..b78127c2b 100644
--- a/tests/ub/out/unsafe/ub6.rs
+++ b/tests/ub/out/unsafe/ub6.rs
@@ -36,6 +36,7 @@ pub unsafe fn any_2(arr: *mut Option<Box<[*mut i32]>>, n1: *mut i32) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -49,3 +50,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { fill_1(&mut arr, &mut n) });
     return ((unsafe { any_2(&mut arr, &mut n) }) as i32);
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/12_test.rs b/tests/unit/out/refcount/12_test.rs
index ba1b9e409..a756517e3 100644
--- a/tests/unit/out/refcount/12_test.rs
+++ b/tests/unit/out/refcount/12_test.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -20,3 +21,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/auto.rs b/tests/unit/out/refcount/auto.rs
index f1628708d..01ad94e17 100644
--- a/tests/unit/out/refcount/auto.rs
+++ b/tests/unit/out/refcount/auto.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 3));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/clone_vs_move.rs b/tests/unit/out/refcount/clone_vs_move.rs
index c3819e4ea..a756a7a1b 100644
--- a/tests/unit/out/refcount/clone_vs_move.rs
+++ b/tests/unit/out/refcount/clone_vs_move.rs
@@ -68,6 +68,7 @@ impl Default for Foo {
 }
 impl ByteRepr for Foo {}
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -506,3 +507,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/complex_function.rs b/tests/unit/out/refcount/complex_function.rs
index c2c67a7c0..76ba6b783 100644
--- a/tests/unit/out/refcount/complex_function.rs
+++ b/tests/unit/out/refcount/complex_function.rs
@@ -110,6 +110,7 @@ impl ByteRepr for X4 {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -420,3 +421,4 @@ impl X4Impl for Ptr<X4> {
         return (*(*self).upgrade().deref()).v.as_pointer();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/compound_assign_ref.rs b/tests/unit/out/refcount/compound_assign_ref.rs
index df941a462..42ac3bffb 100644
--- a/tests/unit/out/refcount/compound_assign_ref.rs
+++ b/tests/unit/out/refcount/compound_assign_ref.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -19,3 +20,4 @@ fn main_0() -> i32 {
     assert!((((v.as_pointer() as Ptr<i32>).read()) == 15));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/cstring.rs b/tests/unit/out/refcount/cstring.rs
index a76123813..2ac030344 100644
--- a/tests/unit/out/refcount/cstring.rs
+++ b/tests/unit/out/refcount/cstring.rs
@@ -912,6 +912,7 @@ pub fn test_strcasecmp_15() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -933,3 +934,4 @@ fn main_0() -> i32 {
     ({ test_strcasecmp_15() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/errno.rs b/tests/unit/out/refcount/errno.rs
index 065a2f4d2..226cb2bf7 100644
--- a/tests/unit/out/refcount/errno.rs
+++ b/tests/unit/out/refcount/errno.rs
@@ -38,6 +38,7 @@ pub fn test_errno_from_fseek_2() {
     libcc2rs::cpp2rust_errno().write(0);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -46,3 +47,4 @@ fn main_0() -> i32 {
     ({ test_errno_from_fseek_2() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fcntl.rs b/tests/unit/out/refcount/fcntl.rs
index b88f7f246..a1a937359 100644
--- a/tests/unit/out/refcount/fcntl.rs
+++ b/tests/unit/out/refcount/fcntl.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -249,3 +250,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(1) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fd_io.rs b/tests/unit/out/refcount/fd_io.rs
index 2cc681801..2ad7329ea 100644
--- a/tests/unit/out/refcount/fd_io.rs
+++ b/tests/unit/out/refcount/fd_io.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -140,3 +141,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/find.rs b/tests/unit/out/refcount/find.rs
index 4ad312318..4e72b3e10 100644
--- a/tests/unit/out/refcount/find.rs
+++ b/tests/unit/out/refcount/find.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -78,3 +79,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs b/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs
index dc405232d..cccb7ef72 100644
--- a/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs
+++ b/tests/unit/out/refcount/fn_ptr_stdlib_compare.rs
@@ -21,6 +21,7 @@ pub fn my_alternative_fwrite_1(p: Ptr<u8>, n: usize, m: usize, f: AnyPtr) -> usi
     return 33_usize;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -271,3 +272,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach.rs b/tests/unit/out/refcount/foreach.rs
index 0a4972280..15b57b218 100644
--- a/tests/unit/out/refcount/foreach.rs
+++ b/tests/unit/out/refcount/foreach.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -27,3 +28,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 45));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
index 7649198e2..af5037f71 100644
--- a/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
+++ b/tests/unit/out/refcount/foreach_disjoint_field_borrow.rs
@@ -37,6 +37,7 @@ impl ByteRepr for S {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -48,3 +49,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_double.rs b/tests/unit/out/refcount/foreach_double.rs
index 668606662..eddf39acb 100644
--- a/tests/unit/out/refcount/foreach_double.rs
+++ b/tests/unit/out/refcount/foreach_double.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -78,3 +79,4 @@ fn main_0() -> i32 {
     assert!(((*square.borrow()) == 144));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_map.rs b/tests/unit/out/refcount/foreach_map.rs
index 042cce5cc..76d65c42d 100644
--- a/tests/unit/out/refcount/foreach_map.rs
+++ b/tests/unit/out/refcount/foreach_map.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 7475_f64));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/foreach_mut.rs b/tests/unit/out/refcount/foreach_mut.rs
index 6418ab6bd..b9589d94a 100644
--- a/tests/unit/out/refcount/foreach_mut.rs
+++ b/tests/unit/out/refcount/foreach_mut.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -64,3 +65,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 168));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/ifaddrs.rs b/tests/unit/out/refcount/ifaddrs.rs
index bc4312479..0c46e9320 100644
--- a/tests/unit/out/refcount/ifaddrs.rs
+++ b/tests/unit/out/refcount/ifaddrs.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -161,3 +162,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/inet_pton_ntop.rs b/tests/unit/out/refcount/inet_pton_ntop.rs
index cdb55376b..3e7ceb4e3 100644
--- a/tests/unit/out/refcount/inet_pton_ntop.rs
+++ b/tests/unit/out/refcount/inet_pton_ntop.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -382,3 +383,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/iterators.rs b/tests/unit/out/refcount/iterators.rs
index 6ea8c0ce3..9eb280bfe 100644
--- a/tests/unit/out/refcount/iterators.rs
+++ b/tests/unit/out/refcount/iterators.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -35,3 +36,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/lseek_ftruncate.rs b/tests/unit/out/refcount/lseek_ftruncate.rs
index 2547c1c10..3a59e1546 100644
--- a/tests/unit/out/refcount/lseek_ftruncate.rs
+++ b/tests/unit/out/refcount/lseek_ftruncate.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -174,3 +175,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/map-reallocation.rs b/tests/unit/out/refcount/map-reallocation.rs
index b2649021e..bb4f3bee2 100644
--- a/tests/unit/out/refcount/map-reallocation.rs
+++ b/tests/unit/out/refcount/map-reallocation.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -104,3 +105,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/map.rs b/tests/unit/out/refcount/map.rs
index 5bf2841c8..d9424f573 100644
--- a/tests/unit/out/refcount/map.rs
+++ b/tests/unit/out/refcount/map.rs
@@ -16,6 +16,7 @@ pub fn bar_1(x: Ptr<u32>) {
     x.write(__rhs);
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -406,3 +407,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memcpy_overlap.rs b/tests/unit/out/refcount/memcpy_overlap.rs
index e10a5708f..59fb28782 100644
--- a/tests/unit/out/refcount/memcpy_overlap.rs
+++ b/tests/unit/out/refcount/memcpy_overlap.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -29,3 +30,4 @@ fn main_0() -> i32 {
     assert!((((*buf.borrow())[(5) as usize] as i32) == 4));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memcpy_struct_bytes.rs b/tests/unit/out/refcount/memcpy_struct_bytes.rs
index 43030c7b2..e6e329860 100644
--- a/tests/unit/out/refcount/memcpy_struct_bytes.rs
+++ b/tests/unit/out/refcount/memcpy_struct_bytes.rs
@@ -35,6 +35,7 @@ impl ByteRepr for point {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -64,3 +65,4 @@ fn main_0() -> i32 {
     assert!(((((*(*dst.borrow()).y.borrow()) == 7) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memcpy_struct_struct.rs b/tests/unit/out/refcount/memcpy_struct_struct.rs
index f5785cf21..e4d725b2c 100644
--- a/tests/unit/out/refcount/memcpy_struct_struct.rs
+++ b/tests/unit/out/refcount/memcpy_struct_struct.rs
@@ -37,6 +37,7 @@ impl ByteRepr for Entry {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -102,3 +103,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/memset.rs b/tests/unit/out/refcount/memset.rs
index f402c7748..96d909a3c 100644
--- a/tests/unit/out/refcount/memset.rs
+++ b/tests/unit/out/refcount/memset.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -34,3 +35,4 @@ fn main_0() -> i32 {
     assert!(((*sum.borrow()) == 50529027));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/netdb.rs b/tests/unit/out/refcount/netdb.rs
index c69604b9f..bd2abecd3 100644
--- a/tests/unit/out/refcount/netdb.rs
+++ b/tests/unit/out/refcount/netdb.rs
@@ -478,6 +478,7 @@ pub fn test_null_hints_2() {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -486,3 +487,4 @@ fn main_0() -> i32 {
     ({ test_null_hints_2() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/new_alloc_array.rs b/tests/unit/out/refcount/new_alloc_array.rs
index c4e12b232..72cc5b564 100644
--- a/tests/unit/out/refcount/new_alloc_array.rs
+++ b/tests/unit/out/refcount/new_alloc_array.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -40,3 +41,4 @@ fn main_0() -> i32 {
     assert!(((*out.borrow()) == 99));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/operator_traits.rs b/tests/unit/out/refcount/operator_traits.rs
index e4c54beb9..30c6b92c8 100644
--- a/tests/unit/out/refcount/operator_traits.rs
+++ b/tests/unit/out/refcount/operator_traits.rs
@@ -259,6 +259,7 @@ impl ByteRepr for Wrapped_int_ {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -518,3 +519,4 @@ impl LtImpl for Ptr<Lt> {
         };
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pipe_io.rs b/tests/unit/out/refcount/pipe_io.rs
index b46063fb4..253057240 100644
--- a/tests/unit/out/refcount/pipe_io.rs
+++ b/tests/unit/out/refcount/pipe_io.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -107,3 +108,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(0) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pointers.rs b/tests/unit/out/refcount/pointers.rs
index 2fb7aa29b..3c1e46bc7 100644
--- a/tests/unit/out/refcount/pointers.rs
+++ b/tests/unit/out/refcount/pointers.rs
@@ -48,6 +48,7 @@ pub fn Update_0(t: Ptr<Test>) -> Ptr<Test> {
     return (*t.borrow()).clone();
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -95,3 +96,4 @@ impl TestImpl for Ptr<Test> {
         (*(*(*self).upgrade().deref()).x.borrow_mut()) = ((*x.borrow()) + (*y.borrow()));
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/poll.rs b/tests/unit/out/refcount/poll.rs
index acf0a506e..6878ee8f3 100644
--- a/tests/unit/out/refcount/poll.rs
+++ b/tests/unit/out/refcount/poll.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -129,3 +130,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(1) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs
index 2fc46195c..28771792d 100644
--- a/tests/unit/out/refcount/push_emplace_back.rs
+++ b/tests/unit/out/refcount/push_emplace_back.rs
@@ -194,6 +194,7 @@ pub fn self_ref_push_6(comps: Ptr<Vec<Chunk>>) {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -332,3 +333,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/pwd.rs b/tests/unit/out/refcount/pwd.rs
index 38af3b897..406bdfdd8 100644
--- a/tests/unit/out/refcount/pwd.rs
+++ b/tests/unit/out/refcount/pwd.rs
@@ -220,6 +220,7 @@ pub fn test_getpwuid_r_erange_3() {
     assert!(((((*result.borrow()).is_null()) as i32) != 0));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -229,3 +230,4 @@ fn main_0() -> i32 {
     ({ test_getpwuid_r_erange_3() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/redundant_copy_in_conversion.rs b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
index ea7213a93..36078ce7f 100644
--- a/tests/unit/out/refcount/redundant_copy_in_conversion.rs
+++ b/tests/unit/out/refcount/redundant_copy_in_conversion.rs
@@ -16,6 +16,7 @@ pub fn sink_0(it: RefcountMapIter<i32, i32>) -> i32 {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -49,3 +50,4 @@ fn main_0() -> i32 {
     assert!(((*r.borrow()) == 2));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/reference_wrapper.rs b/tests/unit/out/refcount/reference_wrapper.rs
index b6850a53b..0def29322 100644
--- a/tests/unit/out/refcount/reference_wrapper.rs
+++ b/tests/unit/out/refcount/reference_wrapper.rs
@@ -47,6 +47,7 @@ pub fn read_1(ref_: Ptr<i32>) -> i32 {
     return (r.read());
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -93,3 +94,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/select.rs b/tests/unit/out/refcount/select.rs
index 732d95175..0bd55094d 100644
--- a/tests/unit/out/refcount/select.rs
+++ b/tests/unit/out/refcount/select.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -322,3 +323,4 @@ fn main_0() -> i32 {
     assert!((((FdRegistry::close((*fds.borrow())[(1) as usize]) == 0) as i32) != 0));
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stdcopy.rs b/tests/unit/out/refcount/stdcopy.rs
index 63e9fea69..1a8322c73 100644
--- a/tests/unit/out/refcount/stdcopy.rs
+++ b/tests/unit/out/refcount/stdcopy.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -28,3 +29,4 @@ fn main_0() -> i32 {
     };
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/stdio_nofd.rs b/tests/unit/out/refcount/stdio_nofd.rs
index 57753ab75..b5dd9a2b8 100644
--- a/tests/unit/out/refcount/stdio_nofd.rs
+++ b/tests/unit/out/refcount/stdio_nofd.rs
@@ -710,6 +710,7 @@ pub fn test_setvbuf_6() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -722,3 +723,4 @@ fn main_0() -> i32 {
     ({ test_setvbuf_6() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/strdup.rs b/tests/unit/out/refcount/strdup.rs
index e20d268b5..0b9565304 100644
--- a/tests/unit/out/refcount/strdup.rs
+++ b/tests/unit/out/refcount/strdup.rs
@@ -31,6 +31,7 @@ impl ByteRepr for record {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -158,3 +159,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/string_h.rs b/tests/unit/out/refcount/string_h.rs
index ca2653f8d..849a0da6d 100644
--- a/tests/unit/out/refcount/string_h.rs
+++ b/tests/unit/out/refcount/string_h.rs
@@ -965,6 +965,7 @@ pub fn test_strcasecmp_14() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -985,3 +986,4 @@ fn main_0() -> i32 {
     ({ test_strcasecmp_14() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/sys_time.rs b/tests/unit/out/refcount/sys_time.rs
index 46a0c95a5..fedcc56bc 100644
--- a/tests/unit/out/refcount/sys_time.rs
+++ b/tests/unit/out/refcount/sys_time.rs
@@ -298,6 +298,7 @@ pub fn test_strftime_5() {
     );
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -307,3 +308,4 @@ fn main_0() -> i32 {
     ({ test_strftime_5() });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_addrof_external.rs b/tests/unit/out/refcount/union_addrof_external.rs
index 6da731326..5c2e89724 100644
--- a/tests/unit/out/refcount/union_addrof_external.rs
+++ b/tests/unit/out/refcount/union_addrof_external.rs
@@ -161,6 +161,7 @@ pub fn fill_1(out: AnyPtr, cap: usize) {
     };
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -223,3 +224,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_cross_arm_cast.rs b/tests/unit/out/refcount/union_cross_arm_cast.rs
index 6732aafd1..7bcd22ef2 100644
--- a/tests/unit/out/refcount/union_cross_arm_cast.rs
+++ b/tests/unit/out/refcount/union_cross_arm_cast.rs
@@ -167,6 +167,7 @@ impl ByteRepr for Container {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -224,3 +225,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_memset_memcpy.rs b/tests/unit/out/refcount/union_memset_memcpy.rs
index d1c758772..89941a561 100644
--- a/tests/unit/out/refcount/union_memset_memcpy.rs
+++ b/tests/unit/out/refcount/union_memset_memcpy.rs
@@ -158,6 +158,7 @@ impl ByteRepr for Container {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -273,3 +274,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_nested.rs b/tests/unit/out/refcount/union_nested.rs
index 124238a8e..53fe44f36 100644
--- a/tests/unit/out/refcount/union_nested.rs
+++ b/tests/unit/out/refcount/union_nested.rs
@@ -185,6 +185,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -233,3 +234,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/union_struct_dual_use.rs b/tests/unit/out/refcount/union_struct_dual_use.rs
index 27a23ef17..34d05eff0 100644
--- a/tests/unit/out/refcount/union_struct_dual_use.rs
+++ b/tests/unit/out/refcount/union_struct_dual_use.rs
@@ -104,6 +104,7 @@ impl ByteRepr for Outer {
     }
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -148,3 +149,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs
index 1227c6012..45cbfd9d1 100644
--- a/tests/unit/out/refcount/vector.rs
+++ b/tests/unit/out/refcount/vector.rs
@@ -10,6 +10,7 @@ pub fn copy_0(copy_vector: Vec<i32>) {
     let copy_vector: Value<Vec<i32>> = Rc::new(RefCell::new(copy_vector));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -239,3 +240,4 @@ fn main_0() -> i32 {
     );
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector3.rs b/tests/unit/out/refcount/vector3.rs
index 66c71b4ba..fc4582462 100644
--- a/tests/unit/out/refcount/vector3.rs
+++ b/tests/unit/out/refcount/vector3.rs
@@ -7,6 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::AsFd;
 use std::rc::{Rc, Weak};
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -76,3 +77,4 @@ fn main_0() -> i32 {
     }
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/vector_with_allocator.rs b/tests/unit/out/refcount/vector_with_allocator.rs
index f217e8bae..9787e6eab 100644
--- a/tests/unit/out/refcount/vector_with_allocator.rs
+++ b/tests/unit/out/refcount/vector_with_allocator.rs
@@ -88,6 +88,7 @@ pub fn fn_1(v: Ptr<Vec<i32>>, v3: Vec<i32>) {
     v.with_mut(|__v: &mut Vec<i32>| __v.push(20));
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -377,3 +378,4 @@ impl TestAllocator_int_Impl for Ptr<TestAllocator_int_> {
         (*p.borrow()).delete_array();
     }
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/refcount/void_return.rs b/tests/unit/out/refcount/void_return.rs
index f1173bb2e..d4458a3ee 100644
--- a/tests/unit/out/refcount/void_return.rs
+++ b/tests/unit/out/refcount/void_return.rs
@@ -13,6 +13,7 @@ pub fn f1_0(first: Ptr<i32>, last: Ptr<i32>) {
     return;
 }
 pub fn main() {
+    __cpp2rust_init_globals();
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
@@ -24,3 +25,4 @@ fn main_0() -> i32 {
     });
     return 0;
 }
+pub fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/04_address_taken_array.rs b/tests/unit/out/unsafe/04_address_taken_array.rs
index 04105f2d0..33a2f71b8 100644
--- a/tests/unit/out/unsafe/04_address_taken_array.rs
+++ b/tests/unit/out/unsafe/04_address_taken_array.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -23,3 +24,4 @@ unsafe fn main_0() -> i32 {
     assert!((((arr2[(0) as usize]) + (arr2[(1) as usize])) == (12)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/09_references.rs b/tests/unit/out/unsafe/09_references.rs
index 7abb38956..197da2316 100644
--- a/tests/unit/out/unsafe/09_references.rs
+++ b/tests/unit/out/unsafe/09_references.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!((((*h_ref1) + (*h_ref2)) == (34)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/11_move.rs b/tests/unit/out/unsafe/11_move.rs
index 22fa8c853..e9774a476 100644
--- a/tests/unit/out/unsafe/11_move.rs
+++ b/tests/unit/out/unsafe/11_move.rs
@@ -17,6 +17,7 @@ pub unsafe fn change_0(n: *mut Option<Box<i32>>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -26,3 +27,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*n.as_deref_mut().unwrap()) == (20)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/13_testing.rs b/tests/unit/out/unsafe/13_testing.rs
index ed7d44c3c..f7ae4a89c 100644
--- a/tests/unit/out/unsafe/13_testing.rs
+++ b/tests/unit/out/unsafe/13_testing.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     (*(*p2)) = 3;
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/alloc_array.rs b/tests/unit/out/unsafe/alloc_array.rs
index be1d513d2..ef7c2dbde 100644
--- a/tests/unit/out/unsafe/alloc_array.rs
+++ b/tests/unit/out/unsafe/alloc_array.rs
@@ -29,6 +29,7 @@ pub unsafe fn Consume_1(mut arr: Option<Box<[i32]>>, mut N: i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { Consume_1(arr.take(), N,) }) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/array_reference.rs b/tests/unit/out/unsafe/array_reference.rs
index 1a39c8411..779f532db 100644
--- a/tests/unit/out/unsafe/array_reference.rs
+++ b/tests/unit/out/unsafe/array_reference.rs
@@ -64,6 +64,7 @@ pub unsafe fn total_len_9(names: *mut [*const libc::c_char; 2]) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -97,3 +98,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { total_len_9(&mut names,) }) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/borrow_mut_opt.rs b/tests/unit/out/unsafe/borrow_mut_opt.rs
index 7ebeca1ea..579f247c0 100644
--- a/tests/unit/out/unsafe/borrow_mut_opt.rs
+++ b/tests/unit/out/unsafe/borrow_mut_opt.rs
@@ -61,6 +61,7 @@ pub unsafe fn convert_with_rhs_1() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -69,3 +70,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { convert_with_rhs_1() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/class.rs b/tests/unit/out/unsafe/class.rs
index 2ac686ffa..89b75608e 100644
--- a/tests/unit/out/unsafe/class.rs
+++ b/tests/unit/out/unsafe/class.rs
@@ -70,6 +70,7 @@ pub unsafe fn RandomRoute_0(route: *mut Route) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -102,3 +103,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index 4d2f0030f..b764f6f73 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -33,6 +33,7 @@ impl Default for Foo {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -247,3 +248,4 @@ unsafe fn main_0() -> i32 {
     }
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/complex_function.rs b/tests/unit/out/unsafe/complex_function.rs
index 20fd319de..de266d91f 100644
--- a/tests/unit/out/unsafe/complex_function.rs
+++ b/tests/unit/out/unsafe/complex_function.rs
@@ -52,6 +52,7 @@ impl X4 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -247,3 +248,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/copy_assign.rs b/tests/unit/out/unsafe/copy_assign.rs
index d1b7469f2..5d5a6cc9e 100644
--- a/tests/unit/out/unsafe/copy_assign.rs
+++ b/tests/unit/out/unsafe/copy_assign.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut assigns_0: i32 = unsafe { 0 };
+pub static mut assigns_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(Default)]
 pub struct Partial {
@@ -30,7 +30,7 @@ impl Partial {
             return &mut (*(self as *mut Partial));
         }
         self.v = (*o).v;
-        assigns_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)).prefix_inc();
         return &mut (*(self as *mut Partial));
     }
 }
@@ -105,6 +105,7 @@ impl Default for Holder {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -114,7 +115,7 @@ unsafe fn main_0() -> i32 {
     let mut c: Partial = Partial::Partial({ 3 }, { 300 });
     (unsafe { Partial::operator_assign(&mut a, &b) });
     assert!(((a.v) == (2)) && ((a.keep) == (100)));
-    assert!(((assigns_0) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (1)));
     (unsafe {
         Partial::operator_assign(
             &mut c,
@@ -122,18 +123,18 @@ unsafe fn main_0() -> i32 {
         )
     });
     assert!(((c.v) == (2)) && ((c.keep) == (300)));
-    assert!(((assigns_0) == (3)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (3)));
     (unsafe {
         let _o: *const Partial = &a;
         Partial::operator_assign(&mut a, _o)
     });
-    assert!(((assigns_0) == (3)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (3)));
     (unsafe {
         let mut _o: Partial = Partial::Partial({ 9 }, { 900 });
         Partial::operator_assign(&mut a, &mut _o)
     });
     assert!(((a.v) == (9)) && ((a.keep) == (100)));
-    assert!(((assigns_0) == (4)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (4)));
     let ra: *mut Partial = &mut a;
     (unsafe {
         let _o: *const Partial = &c;
@@ -146,7 +147,7 @@ unsafe fn main_0() -> i32 {
         Partial::operator_assign(&mut (*pa), _o)
     });
     assert!(((a.v) == (2)));
-    assert!(((assigns_0) == (6)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (6)));
     let mut h: Holder = Holder {
         p: Partial::Partial({ 4 }, { 40 }),
         arr: [
@@ -158,7 +159,7 @@ unsafe fn main_0() -> i32 {
     (unsafe { Partial::operator_assign(&mut h.arr[(1) as usize], &c) });
     assert!(((h.p.v) == (2)) && ((h.p.keep) == (40)));
     assert!(((h.arr[(1) as usize].v) == (2)) && ((h.arr[(1) as usize].keep) == (60)));
-    assert!(((assigns_0) == (8)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut assigns_0)) == (8)));
     let mut n: NonConstAssign = NonConstAssign::NonConstAssign();
     let mut n1: NonConstAssign = NonConstAssign::NonConstAssign();
     let mut n2: NonConstAssign = NonConstAssign::NonConstAssign();
@@ -173,3 +174,6 @@ unsafe fn main_0() -> i32 {
     assert!(((r1.mark) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const assigns_0);
+}
diff --git a/tests/unit/out/unsafe/copy_ctor.rs b/tests/unit/out/unsafe/copy_ctor.rs
index 56bd4a35c..04902a0fd 100644
--- a/tests/unit/out/unsafe/copy_ctor.rs
+++ b/tests/unit/out/unsafe/copy_ctor.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut copies_0: i32 = unsafe { 0 };
+pub static mut copies_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive(Default)]
 pub struct Counted {
@@ -19,7 +19,7 @@ impl Counted {
     }
     pub unsafe fn Counted_pconstCounted(o: *const Counted) -> Self {
         let mut this = Self { v: (*o).v };
-        copies_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)).prefix_inc();
         this
     }
 }
@@ -84,6 +84,7 @@ pub unsafe fn make_2(mut v: i32) -> Counted {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -92,20 +93,20 @@ unsafe fn main_0() -> i32 {
     let mut b: Counted = Counted::Counted_pconstCounted({ &a });
     let mut c: Counted = Counted::Counted_pconstCounted({ &a });
     let mut d: Counted = Counted::Counted_pconstCounted({ &a });
-    assert!(((copies_0) == (3)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (3)));
     assert!((((b.v) == (1)) && ((c.v) == (1))) && ((d.v) == (1)));
     assert!(((unsafe { by_value_1(Counted::Counted_pconstCounted({ &a },),) }) == (1)));
-    assert!(((copies_0) == (4)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (4)));
     let mut e: Counted = (unsafe { make_2(5) });
     assert!(((e.v) == (5)));
-    assert!(((copies_0) == (5)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (5)));
     let mut f: Counted = Counted::Counted({ 6 });
     assert!(((f.v) == (6)));
-    assert!(((copies_0) == (5)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (5)));
     let g: Counted = Counted::Counted({ 7 });
     let mut h: Counted = Counted::Counted_pconstCounted({ &g });
     assert!(((h.v) == (7)));
-    assert!(((copies_0) == (6)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (6)));
     let mut hold: Holder = Holder {
         c: Counted::Counted({ 8 }),
         arr: [Counted::Counted({ 9 }), Counted::Counted({ 10 })],
@@ -115,14 +116,14 @@ unsafe fn main_0() -> i32 {
         (((hold2.c.v) == (8)) && ((hold2.arr[(0) as usize].v) == (9)))
             && ((hold2.arr[(1) as usize].v) == (10))
     );
-    assert!(((copies_0) == (9)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (9)));
     let mut vec_: Vec<Counted> = Vec::new();
     {
         let a0_clone = a.clone();
         vec_.push(a0_clone)
     };
     assert!(((vec_[(0_usize)].v) == (1)));
-    assert!(((copies_0) == (10)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_0)) == (10)));
     let mut n: NonConst = NonConst::NonConst();
     let mut n1: NonConst = NonConst::NonConst_pmutNonConst({ &mut n });
     let cn: NonConst = NonConst::NonConst();
@@ -131,3 +132,6 @@ unsafe fn main_0() -> i32 {
     assert!(((n2.mark) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const copies_0);
+}
diff --git a/tests/unit/out/unsafe/cout_alias.rs b/tests/unit/out/unsafe/cout_alias.rs
index 3b4f50114..01af49f17 100644
--- a/tests/unit/out/unsafe/cout_alias.rs
+++ b/tests/unit/out/unsafe/cout_alias.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -39,3 +40,4 @@ unsafe fn main_0() -> i32 {
     write!((*os2), "hello\n",);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/doubly_linked_list.rs b/tests/unit/out/unsafe/doubly_linked_list.rs
index 0d414e79b..078ba921a 100644
--- a/tests/unit/out/unsafe/doubly_linked_list.rs
+++ b/tests/unit/out/unsafe/doubly_linked_list.rs
@@ -81,6 +81,7 @@ pub unsafe fn Tail_4(mut head: *mut Node) -> *mut Node {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -206,3 +207,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/exprs.rs b/tests/unit/out/unsafe/exprs.rs
index 150824d4c..252df93c2 100644
--- a/tests/unit/out/unsafe/exprs.rs
+++ b/tests/unit/out/unsafe/exprs.rs
@@ -27,6 +27,7 @@ impl Y {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -66,3 +67,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x.x) == (100)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fatorial.rs b/tests/unit/out/unsafe/fatorial.rs
index ad00e181f..923cb5d69 100644
--- a/tests/unit/out/unsafe/fatorial.rs
+++ b/tests/unit/out/unsafe/fatorial.rs
@@ -32,6 +32,7 @@ pub unsafe fn fatorial_by_ptr_2(mut n: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { fatorial_0(n,) }) == (720)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/fft.rs b/tests/unit/out/unsafe/fft.rs
index 88a02fea7..e05c349f0 100644
--- a/tests/unit/out/unsafe/fft.rs
+++ b/tests/unit/out/unsafe/fft.rs
@@ -122,6 +122,7 @@ pub unsafe fn fft_3(a: *mut Option<Box<[Complex]>>, mut N: i32) -> Option<Box<[C
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -171,3 +172,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/foreach_double.rs b/tests/unit/out/unsafe/foreach_double.rs
index ed68831bd..de5255db7 100644
--- a/tests/unit/out/unsafe/foreach_double.rs
+++ b/tests/unit/out/unsafe/foreach_double.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -62,3 +63,4 @@ unsafe fn main_0() -> i32 {
     assert!(((square) == (144)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/friend.rs b/tests/unit/out/unsafe/friend.rs
index 0838e6ce5..629ca16e7 100644
--- a/tests/unit/out/unsafe/friend.rs
+++ b/tests/unit/out/unsafe/friend.rs
@@ -55,6 +55,7 @@ pub unsafe fn declared_then_defined_6(d: *const D) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -85,3 +86,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { declared_then_defined_6(&d,) }) == (8)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/function_overloading.rs b/tests/unit/out/unsafe/function_overloading.rs
index a1ea21e66..9036aeebb 100644
--- a/tests/unit/out/unsafe/function_overloading.rs
+++ b/tests/unit/out/unsafe/function_overloading.rs
@@ -40,6 +40,7 @@ pub unsafe fn func_6(mut x: *mut i32) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -71,3 +72,4 @@ unsafe fn main_0() -> i32 {
     assert!(((out) == (13)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/global_non_const_init.rs b/tests/unit/out/unsafe/global_non_const_init.rs
index 5a5d5b8fb..22bfd5039 100644
--- a/tests/unit/out/unsafe/global_non_const_init.rs
+++ b/tests/unit/out/unsafe/global_non_const_init.rs
@@ -89,7 +89,7 @@ impl Singleton {
     pub unsafe fn instance() -> *mut Singleton {
         static mut s_15: std::cell::LazyCell<Singleton> =
             std::cell::LazyCell::new(|| unsafe { Singleton::Singleton() });;
-        return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut s_15)) as *mut Singleton;
+        return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut s_15));
     }
 }
 impl Default for Singleton {
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
index ce0a42937..28d8c922c 100644
--- a/tests/unit/out/unsafe/huffman.rs
+++ b/tests/unit/out/unsafe/huffman.rs
@@ -261,6 +261,7 @@ pub unsafe fn HuffmanCodes_5(
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -302,3 +303,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/init.rs b/tests/unit/out/unsafe/init.rs
index c4b49a67e..78f74b321 100644
--- a/tests/unit/out/unsafe/init.rs
+++ b/tests/unit/out/unsafe/init.rs
@@ -16,6 +16,7 @@ pub unsafe fn func_0() -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     aa = (unsafe { func_0() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/kruskal.rs b/tests/unit/out/unsafe/kruskal.rs
index cb48b4dce..cb9dc569d 100644
--- a/tests/unit/out/unsafe/kruskal.rs
+++ b/tests/unit/out/unsafe/kruskal.rs
@@ -184,6 +184,7 @@ pub unsafe fn MSTKruskal_2(graph: *mut Graph) -> f64 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -228,3 +229,4 @@ unsafe fn main_0() -> i32 {
     assert!(((total_weight) == (19_f64)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/linked_list.rs b/tests/unit/out/unsafe/linked_list.rs
index 8fadd3851..bdfaa8c78 100644
--- a/tests/unit/out/unsafe/linked_list.rs
+++ b/tests/unit/out/unsafe/linked_list.rs
@@ -52,6 +52,7 @@ pub unsafe fn Delete_2(mut head: *mut Node, mut val: i32) -> *mut Node {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -137,3 +138,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/map.rs b/tests/unit/out/unsafe/map.rs
index 25c49b6cc..67472d7f9 100644
--- a/tests/unit/out/unsafe/map.rs
+++ b/tests/unit/out/unsafe/map.rs
@@ -14,6 +14,7 @@ pub unsafe fn bar_1(x: *mut u32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -149,3 +150,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/move_assign.rs b/tests/unit/out/unsafe/move_assign.rs
index 5c9f54c98..dcbd5643b 100644
--- a/tests/unit/out/unsafe/move_assign.rs
+++ b/tests/unit/out/unsafe/move_assign.rs
@@ -66,6 +66,7 @@ pub unsafe fn make_0(mut v: i32) -> MoveOnly {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -118,3 +119,4 @@ unsafe fn main_0() -> i32 {
     assert!(((m2.mark) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/move_this.rs b/tests/unit/out/unsafe/move_this.rs
index 75b912f1b..898fbed22 100644
--- a/tests/unit/out/unsafe/move_this.rs
+++ b/tests/unit/out/unsafe/move_this.rs
@@ -57,6 +57,7 @@ pub unsafe fn consume_0(mut c: Chain) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -86,3 +87,4 @@ unsafe fn main_0() -> i32 {
     assert!(((f.v) == (31)) && ((e.v) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/new_array_var_size.rs b/tests/unit/out/unsafe/new_array_var_size.rs
index e9e34ea5b..fbea43fc9 100644
--- a/tests/unit/out/unsafe/new_array_var_size.rs
+++ b/tests/unit/out/unsafe/new_array_var_size.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -30,3 +31,4 @@ unsafe fn main_0() -> i32 {
     )));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_arithmetic_free.rs b/tests/unit/out/unsafe/operator_arithmetic_free.rs
index 07abe9a05..01a1a6e1f 100644
--- a/tests/unit/out/unsafe/operator_arithmetic_free.rs
+++ b/tests/unit/out/unsafe/operator_arithmetic_free.rs
@@ -72,6 +72,7 @@ pub unsafe fn operator_add_12(mut a: i32, b: *const S) -> S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -167,3 +168,4 @@ unsafe fn main_0() -> i32 {
     assert!((((unsafe { operator_add_12(1, &a,) }).v) == (8)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_arithmetic_member.rs b/tests/unit/out/unsafe/operator_arithmetic_member.rs
index 268866bca..2985c21bd 100644
--- a/tests/unit/out/unsafe/operator_arithmetic_member.rs
+++ b/tests/unit/out/unsafe/operator_arithmetic_member.rs
@@ -64,6 +64,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -89,3 +90,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_bitwise_free.rs b/tests/unit/out/unsafe/operator_bitwise_free.rs
index 5bfdae44b..ef4ec64e6 100644
--- a/tests/unit/out/unsafe/operator_bitwise_free.rs
+++ b/tests/unit/out/unsafe/operator_bitwise_free.rs
@@ -41,6 +41,7 @@ pub unsafe fn operator_shr_5(a: *const S, mut n: i32) -> S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -91,3 +92,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_bitwise_member.rs b/tests/unit/out/unsafe/operator_bitwise_member.rs
index 161a57fa4..379a83976 100644
--- a/tests/unit/out/unsafe/operator_bitwise_member.rs
+++ b/tests/unit/out/unsafe/operator_bitwise_member.rs
@@ -43,6 +43,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     assert!((((unsafe { S::operator_shr(&a, 2,) }).v) == (3_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_defaulted.rs b/tests/unit/out/unsafe/operator_comparison_defaulted.rs
index a4c454c58..c25fc6f11 100644
--- a/tests/unit/out/unsafe/operator_comparison_defaulted.rs
+++ b/tests/unit/out/unsafe/operator_comparison_defaulted.rs
@@ -272,6 +272,7 @@ impl std::cmp::PartialEq for Secondary {
 impl std::cmp::Eq for Secondary {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -330,3 +331,4 @@ unsafe fn main_0() -> i32 {
     assert!(!(unsafe { Secondary::operator_lt(&s2, &s1,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_free.rs b/tests/unit/out/unsafe/operator_comparison_free.rs
index ecf85bb0b..19d1562b7 100644
--- a/tests/unit/out/unsafe/operator_comparison_free.rs
+++ b/tests/unit/out/unsafe/operator_comparison_free.rs
@@ -61,6 +61,7 @@ pub unsafe fn operator_lt_7(mut a: i32, b: *const S) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -119,3 +120,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { operator_lt_7(0, &a,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_member.rs b/tests/unit/out/unsafe/operator_comparison_member.rs
index 12b44efac..946888fef 100644
--- a/tests/unit/out/unsafe/operator_comparison_member.rs
+++ b/tests/unit/out/unsafe/operator_comparison_member.rs
@@ -60,6 +60,7 @@ impl std::cmp::PartialEq for S {
 impl std::cmp::Eq for S {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -77,3 +78,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { S::operator_lt_i32_const(&a, 5,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_mixed.rs b/tests/unit/out/unsafe/operator_comparison_mixed.rs
index 47bc31c8a..dedb10c47 100644
--- a/tests/unit/out/unsafe/operator_comparison_mixed.rs
+++ b/tests/unit/out/unsafe/operator_comparison_mixed.rs
@@ -54,6 +54,7 @@ pub unsafe fn operator_lt_6(a: *mut S, mut b: i32) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -86,3 +87,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
index a4f9676d6..0d24bd4c6 100644
--- a/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
+++ b/tests/unit/out/unsafe/operator_comparison_noncopyable.rs
@@ -49,6 +49,7 @@ impl std::cmp::PartialEq for S {
 impl std::cmp::Eq for S {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -76,3 +77,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_compound_assignment_free.rs b/tests/unit/out/unsafe/operator_compound_assignment_free.rs
index b432a0378..f0f0d5a56 100644
--- a/tests/unit/out/unsafe/operator_compound_assignment_free.rs
+++ b/tests/unit/out/unsafe/operator_compound_assignment_free.rs
@@ -53,6 +53,7 @@ pub unsafe fn operator_shr_assign_9(a: *mut S, mut n: i32) -> *mut S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -121,3 +122,4 @@ unsafe fn main_0() -> i32 {
     assert!(((a.v) == (14_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_compound_assignment_member.rs b/tests/unit/out/unsafe/operator_compound_assignment_member.rs
index 8d169d4e6..40fbc78c0 100644
--- a/tests/unit/out/unsafe/operator_compound_assignment_member.rs
+++ b/tests/unit/out/unsafe/operator_compound_assignment_member.rs
@@ -59,6 +59,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -98,3 +99,4 @@ unsafe fn main_0() -> i32 {
     assert!(((c.v) == (1_u32)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_less_than.rs b/tests/unit/out/unsafe/operator_less_than.rs
index 364a0df8c..7d8dd400d 100644
--- a/tests/unit/out/unsafe/operator_less_than.rs
+++ b/tests/unit/out/unsafe/operator_less_than.rs
@@ -47,6 +47,7 @@ impl std::cmp::PartialEq for Pair {
 impl std::cmp::Eq for Pair {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -56,3 +57,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { Pair::operator_lt(&mut pair1, &pair2,) }));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_logical_free.rs b/tests/unit/out/unsafe/operator_logical_free.rs
index 459c83299..176f335b9 100644
--- a/tests/unit/out/unsafe/operator_logical_free.rs
+++ b/tests/unit/out/unsafe/operator_logical_free.rs
@@ -22,6 +22,7 @@ pub unsafe fn operator_or_2(a: *const S, b: *const S) -> bool {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -68,3 +69,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_logical_member.rs b/tests/unit/out/unsafe/operator_logical_member.rs
index d0c47a73e..3c97c6f6c 100644
--- a/tests/unit/out/unsafe/operator_logical_member.rs
+++ b/tests/unit/out/unsafe/operator_logical_member.rs
@@ -24,6 +24,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -48,3 +49,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_member_pointer_free.rs b/tests/unit/out/unsafe/operator_member_pointer_free.rs
index ba2612366..308f1c5a9 100644
--- a/tests/unit/out/unsafe/operator_member_pointer_free.rs
+++ b/tests/unit/out/unsafe/operator_member_pointer_free.rs
@@ -33,6 +33,7 @@ pub unsafe fn operator_addr_1(s: *mut S) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -63,3 +64,4 @@ unsafe fn main_0() -> i32 {
     assert!(((s.data[(0) as usize]) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_member_pointer_member.rs b/tests/unit/out/unsafe/operator_member_pointer_member.rs
index f18369803..59f1153f6 100644
--- a/tests/unit/out/unsafe/operator_member_pointer_member.rs
+++ b/tests/unit/out/unsafe/operator_member_pointer_member.rs
@@ -16,10 +16,11 @@ pub struct Inner {
 pub struct Table {}
 impl Table {
     pub unsafe fn operator_index(mut i: i32) -> *mut i32 {
-        return &mut table_0[(i) as usize];
+        return &mut (*std::cell::LazyCell::force_mut(&mut *&raw mut table_0))[(i) as usize];
     }
 }
-pub static mut table_0: [i32; 3] = unsafe { [7, 8, 9] };
+pub static mut table_0: std::cell::LazyCell<[i32; 3]> =
+    std::cell::LazyCell::new(|| unsafe { [7, 8, 9] });
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct S {
@@ -53,6 +54,7 @@ impl Default for S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -78,6 +80,9 @@ unsafe fn main_0() -> i32 {
     let mut t: Table = <Table>::default();
     assert!(((*(unsafe { Table::operator_index(1,) })) == (8)));
     (*(unsafe { Table::operator_index(1) })) = 80;
-    assert!(((table_0[(1) as usize]) == (80)));
+    assert!((((*std::cell::LazyCell::force_mut(&mut *&raw mut table_0))[(1) as usize]) == (80)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const table_0);
+}
diff --git a/tests/unit/out/unsafe/operator_other_free.rs b/tests/unit/out/unsafe/operator_other_free.rs
index 5d6da5e57..eb1f4e6bf 100644
--- a/tests/unit/out/unsafe/operator_other_free.rs
+++ b/tests/unit/out/unsafe/operator_other_free.rs
@@ -18,6 +18,7 @@ pub unsafe fn operator_comma_0(a: *const S, b: *const S) -> S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_other_member.rs b/tests/unit/out/unsafe/operator_other_member.rs
index 03c53a9ac..ab10d9766 100644
--- a/tests/unit/out/unsafe/operator_other_member.rs
+++ b/tests/unit/out/unsafe/operator_other_member.rs
@@ -43,6 +43,7 @@ impl S {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -67,3 +68,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { Static::operator_call(6, 7,) }) == (42)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_overloads.rs b/tests/unit/out/unsafe/operator_overloads.rs
index 50de25ab4..a6e742561 100644
--- a/tests/unit/out/unsafe/operator_overloads.rs
+++ b/tests/unit/out/unsafe/operator_overloads.rs
@@ -54,6 +54,7 @@ pub unsafe fn operator_eq_5(mut a: i64, b: *const S) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -96,3 +97,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { operator_eq_5(6_i64, &s,) }) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/operator_three_way.rs b/tests/unit/out/unsafe/operator_three_way.rs
index 3145dbc77..7ded6102f 100644
--- a/tests/unit/out/unsafe/operator_three_way.rs
+++ b/tests/unit/out/unsafe/operator_three_way.rs
@@ -43,6 +43,7 @@ impl std::cmp::PartialEq for S {
 impl std::cmp::Eq for S {}
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     assert!((unsafe { S::operator_cmp(&a, &b,) }) == std::cmp::Ordering::Less);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pod.rs b/tests/unit/out/unsafe/pod.rs
index 181a2b9af..00ea9c182 100644
--- a/tests/unit/out/unsafe/pod.rs
+++ b/tests/unit/out/unsafe/pod.rs
@@ -20,6 +20,7 @@ pub unsafe fn PODIncrement_0(pod: *mut POD) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -38,3 +39,4 @@ unsafe fn main_0() -> i32 {
     assert!(((((p2.x1) + (p2.x2)) + (p2.x3)) == (39)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/pointer_array.rs b/tests/unit/out/unsafe/pointer_array.rs
index 121112920..1689684b9 100644
--- a/tests/unit/out/unsafe/pointer_array.rs
+++ b/tests/unit/out/unsafe/pointer_array.rs
@@ -27,6 +27,7 @@ pub unsafe fn IncrementAll_0(s: *mut StackArray) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -43,3 +44,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (3)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/printfs.rs b/tests/unit/out/unsafe/printfs.rs
index 55fe7854b..46441563e 100644
--- a/tests/unit/out/unsafe/printfs.rs
+++ b/tests/unit/out/unsafe/printfs.rs
@@ -24,6 +24,7 @@ pub unsafe fn fn2_1(v: *const Vec<libc::c_char>) -> *const Vec<libc::c_char> {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -57,3 +58,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/prvalue-as-lvalue.rs b/tests/unit/out/unsafe/prvalue-as-lvalue.rs
index 7dfaf49a8..688a192fc 100644
--- a/tests/unit/out/unsafe/prvalue-as-lvalue.rs
+++ b/tests/unit/out/unsafe/prvalue-as-lvalue.rs
@@ -11,6 +11,7 @@ pub unsafe fn foo_0(a: *const i32) -> *const i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*b) == (1)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/random.rs b/tests/unit/out/unsafe/random.rs
index 106726b17..69935a4f8 100644
--- a/tests/unit/out/unsafe/random.rs
+++ b/tests/unit/out/unsafe/random.rs
@@ -60,6 +60,7 @@ pub unsafe fn foo_1(mut x1: i32, x2: *mut i32, mut x3: *mut i32, p2: *mut Pair,
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -221,3 +222,4 @@ unsafe fn main_0() -> i32 {
     let mut ptr2ptr_2: *mut *mut Pair = (&mut py1 as *mut *mut Pair);
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/rebind.rs b/tests/unit/out/unsafe/rebind.rs
index bd96f5c8c..b62787ec3 100644
--- a/tests/unit/out/unsafe/rebind.rs
+++ b/tests/unit/out/unsafe/rebind.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -20,3 +21,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (10)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/ref_calls.rs b/tests/unit/out/unsafe/ref_calls.rs
index 8a1f4e564..271182015 100644
--- a/tests/unit/out/unsafe/ref_calls.rs
+++ b/tests/unit/out/unsafe/ref_calls.rs
@@ -14,6 +14,7 @@ pub unsafe fn foo_1(x: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/references.rs b/tests/unit/out/unsafe/references.rs
index 13c26f772..82c1db2d7 100644
--- a/tests/unit/out/unsafe/references.rs
+++ b/tests/unit/out/unsafe/references.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -18,3 +19,4 @@ unsafe fn main_0() -> i32 {
     assert!(((x) == (5)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/references2.rs b/tests/unit/out/unsafe/references2.rs
index 812b637d4..04a3ea9d4 100644
--- a/tests/unit/out/unsafe/references2.rs
+++ b/tests/unit/out/unsafe/references2.rs
@@ -12,6 +12,7 @@ pub unsafe fn change_0(p: *mut Option<Box<i32>>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*a.as_deref_mut().unwrap()) == (7)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/refs_as_args.rs b/tests/unit/out/unsafe/refs_as_args.rs
index b71d10a62..d75586040 100644
--- a/tests/unit/out/unsafe/refs_as_args.rs
+++ b/tests/unit/out/unsafe/refs_as_args.rs
@@ -19,6 +19,7 @@ pub unsafe fn more_refs_0(mut x1: i32, mut x2: i32, r1: *mut i32, r2: *const i32
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -29,3 +30,4 @@ unsafe fn main_0() -> i32 {
     assert!((((x1) + (x2)) == (21)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/rule_of_five.rs b/tests/unit/out/unsafe/rule_of_five.rs
index d38782249..353246c33 100644
--- a/tests/unit/out/unsafe/rule_of_five.rs
+++ b/tests/unit/out/unsafe/rule_of_five.rs
@@ -6,9 +6,9 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut alive_0: i32 = unsafe { 0 };
-pub static mut copies_1: i32 = unsafe { 0 };
-pub static mut moves_2: i32 = unsafe { 0 };
+pub static mut alive_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+pub static mut copies_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+pub static mut moves_2: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive()]
 pub struct Buffer {
@@ -26,11 +26,11 @@ impl Buffer {
             this.data[(i) as usize] = if ((i) < (size)) { i } else { -1_i32 };
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
         this
     }
     pub unsafe fn destructor(&mut self) {
-        alive_0.prefix_dec();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_dec();
     }
     pub unsafe fn Buffer_pconstBuffer(o: *const Buffer) -> Self {
         let mut this = Self {
@@ -42,8 +42,8 @@ impl Buffer {
             this.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         this
     }
     pub unsafe fn Buffer_pmutBuffer(o: *mut Buffer) -> Self {
@@ -58,8 +58,8 @@ impl Buffer {
             i.prefix_inc();
         }
         (*o).size = 0;
-        alive_0.prefix_inc();
-        moves_2.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)).prefix_inc();
         this
     }
     pub unsafe fn operator_assign_pconstBuffer(&mut self, o: *const Buffer) -> *mut Buffer {
@@ -72,7 +72,7 @@ impl Buffer {
             self.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         return &mut (*(self as *mut Buffer));
     }
     pub unsafe fn operator_assign_pmutBuffer(&mut self, o: *mut Buffer) -> *mut Buffer {
@@ -87,7 +87,7 @@ impl Buffer {
             i.prefix_inc();
         }
         (*o).size = 0;
-        moves_2.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)).prefix_inc();
         return &mut (*(self as *mut Buffer));
     }
 }
@@ -111,6 +111,7 @@ pub unsafe fn make_3(mut size: i32) -> Buffer {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -120,27 +121,49 @@ unsafe fn main_0() -> i32 {
         let _dtor_a = ScopedDestructorUnsafe::new(&raw mut a, Buffer::destructor);
         let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a });
         let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Buffer::destructor);
-        assert!((((alive_0) == (2)) && ((copies_1) == (1))) && ((moves_2) == (0)));
+        assert!(
+            (((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (2))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (1)))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (0))
+        );
         b.data[(0) as usize] = 100;
         assert!(((a.data[(0) as usize]) == (0)));
         let mut c: Buffer = Buffer::Buffer_pmutBuffer({ &mut a });
         let _dtor_c = ScopedDestructorUnsafe::new(&raw mut c, Buffer::destructor);
-        assert!(((alive_0) == (3)) && ((moves_2) == (1)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (3))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (1))
+        );
         assert!(((a.size) == (0)) && ((a.data[(0) as usize]) == (-1_i32)));
         assert!(((c.size) == (4)) && ((c.data[(3) as usize]) == (3)));
         let mut d: Buffer = (unsafe { make_3(2) });
         let _dtor_d = ScopedDestructorUnsafe::new(&raw mut d, Buffer::destructor);
-        assert!(((d.size) == (2)) && ((moves_2) == (2)));
+        assert!(
+            ((d.size) == (2)) && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (2))
+        );
         (unsafe { Buffer::operator_assign_pconstBuffer(&mut d, &b) });
-        assert!((((d.size) == (4)) && ((d.data[(0) as usize]) == (100))) && ((copies_1) == (2)));
+        assert!(
+            (((d.size) == (4)) && ((d.data[(0) as usize]) == (100)))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (2))
+        );
         (unsafe { Buffer::operator_assign_pmutBuffer(&mut d, &mut c) });
-        assert!((((d.data[(0) as usize]) == (0)) && ((c.size) == (0))) && ((moves_2) == (3)));
+        assert!(
+            (((d.data[(0) as usize]) == (0)) && ((c.size) == (0)))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (3))
+        );
         (unsafe {
             let _o: *mut Buffer = &mut d;
             Buffer::operator_assign_pmutBuffer(&mut d, _o)
         });
-        assert!(((d.size) == (4)) && ((moves_2) == (3)));
+        assert!(
+            ((d.size) == (4)) && ((*std::cell::LazyCell::force_mut(&mut *&raw mut moves_2)) == (3))
+        );
     }
-    assert!(((alive_0) == (0)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const alive_0);
+    std::cell::LazyCell::force(&*&raw const copies_1);
+    std::cell::LazyCell::force(&*&raw const moves_2);
+}
diff --git a/tests/unit/out/unsafe/rule_of_three.rs b/tests/unit/out/unsafe/rule_of_three.rs
index f358e0260..b6311867c 100644
--- a/tests/unit/out/unsafe/rule_of_three.rs
+++ b/tests/unit/out/unsafe/rule_of_three.rs
@@ -6,8 +6,8 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub static mut alive_0: i32 = unsafe { 0 };
-pub static mut copies_1: i32 = unsafe { 0 };
+pub static mut alive_0: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
+pub static mut copies_1: std::cell::LazyCell<i32> = std::cell::LazyCell::new(|| unsafe { 0 });
 #[repr(C)]
 #[derive()]
 pub struct Buffer {
@@ -25,11 +25,11 @@ impl Buffer {
             this.data[(i) as usize] = if ((i) < (size)) { i } else { -1_i32 };
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
         this
     }
     pub unsafe fn destructor(&mut self) {
-        alive_0.prefix_dec();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_dec();
     }
     pub unsafe fn Buffer_pconstBuffer(o: *const Buffer) -> Self {
         let mut this = Self {
@@ -41,8 +41,8 @@ impl Buffer {
             this.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        alive_0.prefix_inc();
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)).prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         this
     }
     pub unsafe fn operator_assign(&mut self, o: *const Buffer) -> *mut Buffer {
@@ -55,7 +55,7 @@ impl Buffer {
             self.data[(i) as usize] = (*o).data[(i) as usize];
             i.prefix_inc();
         }
-        copies_1.prefix_inc();
+        (*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)).prefix_inc();
         return &mut (*(self as *mut Buffer));
     }
 }
@@ -83,6 +83,7 @@ pub unsafe fn sum_2(b: *const Buffer) -> i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -92,29 +93,42 @@ unsafe fn main_0() -> i32 {
         let _dtor_a = ScopedDestructorUnsafe::new(&raw mut a, Buffer::destructor);
         let mut b: Buffer = Buffer::Buffer_pconstBuffer({ &a });
         let _dtor_b = ScopedDestructorUnsafe::new(&raw mut b, Buffer::destructor);
-        assert!(((alive_0) == (2)) && ((copies_1) == (1)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (2))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (1))
+        );
         b.data[(0) as usize] = 100;
         assert!(((a.data[(0) as usize]) == (0)));
         let mut c: Buffer = Buffer::Buffer({ 2 });
         let _dtor_c = ScopedDestructorUnsafe::new(&raw mut c, Buffer::destructor);
         (unsafe { Buffer::operator_assign(&mut c, &a) });
         assert!(((c.size) == (4)) && ((c.data[(3) as usize]) == (3)));
-        assert!(((alive_0) == (3)) && ((copies_1) == (2)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (3))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (2))
+        );
         (unsafe {
             let _o: *const Buffer = &c;
             Buffer::operator_assign(&mut c, _o)
         });
-        assert!(((copies_1) == (2)));
+        assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (2)));
         assert!(((unsafe { sum_2(&a,) }) == (6)));
         assert!(((unsafe { sum_2(&b,) }) == (106)));
         let mut d: Buffer = Buffer::Buffer_pconstBuffer({ &mut a });
         let _dtor_d = ScopedDestructorUnsafe::new(&raw mut d, Buffer::destructor);
-        assert!(((alive_0) == (4)) && ((copies_1) == (3)));
+        assert!(
+            ((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (4))
+                && ((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (3))
+        );
         assert!(((a.size) == (4)) && ((a.data[(3) as usize]) == (3)));
         (unsafe { Buffer::operator_assign(&mut d, &mut b) });
-        assert!(((copies_1) == (4)));
+        assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut copies_1)) == (4)));
         assert!(((b.data[(0) as usize]) == (100)) && ((d.data[(0) as usize]) == (100)));
     }
-    assert!(((alive_0) == (0)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut alive_0)) == (0)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const alive_0);
+    std::cell::LazyCell::force(&*&raw const copies_1);
+}
diff --git a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
index 561b4b24b..6eded9e98 100644
--- a/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
+++ b/tests/unit/out/unsafe/split_binop_aliased_borrows.rs
@@ -8,6 +8,7 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -19,3 +20,4 @@ unsafe fn main_0() -> i32 {
     assert!(((v[(0_usize)]) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/struct_ctor.rs b/tests/unit/out/unsafe/struct_ctor.rs
index 7e2d6c9c2..b3f9d9e98 100644
--- a/tests/unit/out/unsafe/struct_ctor.rs
+++ b/tests/unit/out/unsafe/struct_ctor.rs
@@ -31,6 +31,7 @@ pub unsafe fn foo_0(x: *mut i32) -> *mut i32 {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -44,3 +45,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/swap.rs b/tests/unit/out/unsafe/swap.rs
index 6ca3f6451..c3494104e 100644
--- a/tests/unit/out/unsafe/swap.rs
+++ b/tests/unit/out/unsafe/swap.rs
@@ -21,6 +21,7 @@ pub unsafe fn swap_by_ref_2(a: *mut i32, b: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -37,3 +38,4 @@ unsafe fn main_0() -> i32 {
     assert!(((c) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/swap_extended.rs b/tests/unit/out/unsafe/swap_extended.rs
index 902a68989..9fb5a9578 100644
--- a/tests/unit/out/unsafe/swap_extended.rs
+++ b/tests/unit/out/unsafe/swap_extended.rs
@@ -21,6 +21,7 @@ pub unsafe fn swap_by_ref_2(a: *mut i32, b: *mut i32) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -157,3 +158,4 @@ unsafe fn main_0() -> i32 {
     assert!(((c) == (2)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/this.rs b/tests/unit/out/unsafe/this.rs
index bd7ea5eb0..287533571 100644
--- a/tests/unit/out/unsafe/this.rs
+++ b/tests/unit/out/unsafe/this.rs
@@ -113,6 +113,7 @@ impl D {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -185,3 +186,4 @@ unsafe fn main_0() -> i32 {
     assert!((u1.self__).is_null());
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr.rs b/tests/unit/out/unsafe/unique_ptr.rs
index 5b7006007..296970de6 100644
--- a/tests/unit/out/unsafe/unique_ptr.rs
+++ b/tests/unit/out/unsafe/unique_ptr.rs
@@ -144,6 +144,7 @@ pub unsafe fn RndStuff_2() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -154,3 +155,4 @@ unsafe fn main_0() -> i32 {
     assert!(((unsafe { Consume_1(safe_ptr.take(),) }) == (60)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unique_ptr_small.rs b/tests/unit/out/unsafe/unique_ptr_small.rs
index 4645417f3..9521f17bf 100644
--- a/tests/unit/out/unsafe/unique_ptr_small.rs
+++ b/tests/unit/out/unsafe/unique_ptr_small.rs
@@ -12,6 +12,7 @@ pub unsafe fn change_0(n: *mut Option<Box<i32>>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -21,3 +22,4 @@ unsafe fn main_0() -> i32 {
     assert!(((*n.as_deref_mut().unwrap()) == (20)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/unistd.rs b/tests/unit/out/unsafe/unistd.rs
index ef426d0cc..298535d2c 100644
--- a/tests/unit/out/unsafe/unistd.rs
+++ b/tests/unit/out/unsafe/unistd.rs
@@ -292,6 +292,7 @@ pub unsafe fn test_gethostname_11() {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -310,3 +311,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { test_gethostname_11() });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector2.rs b/tests/unit/out/unsafe/vector2.rs
index 1fd2d1a7c..ecc50db3c 100644
--- a/tests/unit/out/unsafe/vector2.rs
+++ b/tests/unit/out/unsafe/vector2.rs
@@ -33,6 +33,7 @@ pub unsafe fn fn_0(v: *mut Vec<i32>, mut v3: Vec<i32>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -47,3 +48,4 @@ unsafe fn main_0() -> i32 {
     (unsafe { fn_0(&mut v, v2.clone()) });
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/vector_with_allocator.rs b/tests/unit/out/unsafe/vector_with_allocator.rs
index 178b6609a..b019d5ef7 100644
--- a/tests/unit/out/unsafe/vector_with_allocator.rs
+++ b/tests/unit/out/unsafe/vector_with_allocator.rs
@@ -58,6 +58,7 @@ pub unsafe fn fn_1(v: *mut Vec<i32>, mut v3: Vec<i32>) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -247,3 +248,4 @@ unsafe fn main_0() -> i32 {
     );
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {}
diff --git a/tests/unit/out/unsafe/void_cast.rs b/tests/unit/out/unsafe/void_cast.rs
index aea1827dc..a17297040 100644
--- a/tests/unit/out/unsafe/void_cast.rs
+++ b/tests/unit/out/unsafe/void_cast.rs
@@ -20,10 +20,11 @@ pub unsafe fn unused_ref_param_1(x: *const NonTrivial) {
 pub unsafe fn unused_ptr_param_2(mut p: *const NonTrivial) {
     &(*p);
 }
-pub static mut side_effect_counter_3: i32 = unsafe { 0 };
+pub static mut side_effect_counter_3: std::cell::LazyCell<i32> =
+    std::cell::LazyCell::new(|| unsafe { 0 });
 pub unsafe fn bump_and_return_4() -> i32 {
-    side_effect_counter_3.prefix_inc();
-    return side_effect_counter_3;
+    (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)).prefix_inc();
+    return (*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3));
 }
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
@@ -40,6 +41,7 @@ pub unsafe fn unused_noncopyable_param_5(x: *const NonCopyable) {
 }
 pub fn main() {
     unsafe {
+        __cpp2rust_init_globals();
         std::process::exit(main_0() as i32);
     }
 }
@@ -61,12 +63,12 @@ unsafe fn main_0() -> i32 {
     assert!(((w) == (3)));
     assert!(((counter) == (3)));
     &(unsafe { bump_and_return_4() });
-    assert!(((side_effect_counter_3) == (1)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (1)));
     let mut v: i32 = {
         &(unsafe { bump_and_return_4() });
         99
     };
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     assert!(((v) == (99)));
     &(0);
     &(0);
@@ -83,13 +85,13 @@ unsafe fn main_0() -> i32 {
     assert!(((err) == (7)));
     assert!(((chosen) == (123)));
     &(bump_and_return_4);
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     &(Some(bump_and_return_4));
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     &(std::mem::transmute::<Option<unsafe fn() -> i32>, Option<unsafe fn() -> i32>>(
         (Some(bump_and_return_4)),
     ));
-    assert!(((side_effect_counter_3) == (2)));
+    assert!(((*std::cell::LazyCell::force_mut(&mut *&raw mut side_effect_counter_3)) == (2)));
     let mut storage: i32 = 11;
     let mut p: *mut i32 = (&mut storage as *mut i32);
     &(*p);
@@ -112,3 +114,6 @@ unsafe fn main_0() -> i32 {
     assert!(((*g.value.as_deref_mut().unwrap()) == (9)));
     return 0;
 }
+pub unsafe fn __cpp2rust_init_globals() {
+    std::cell::LazyCell::force(&*&raw const side_effect_counter_3);
+}

From b961b0fa85d324c2a399589b3771700716691331 Mon Sep 17 00:00:00 2001
From: Nuno Lopes <nuno.lopes@tecnico.ulisboa.pt>
Date: Thu, 17 Sep 2026 14:12:31 +0100
Subject: [PATCH 7/9] optimize

---
 cpp2rust/converter/models/converter_refcount.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 5a0e8dfc7..eff715db8 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -2449,9 +2449,7 @@ void ConverterRefCount::ConvertPointerSubscript(
 }
 
 std::string ConverterRefCount::ForceGlobalInit(const clang::VarDecl *decl) {
-  const auto *clone =
-      decl->getType()->isReferenceType() ? "Ptr::clone" : "Value::clone";
-  return std::format("let _ = {}.with({});", GetNamedDeclAsString(decl), clone);
+  return std::format("let _ = {}.with(|_| ());", GetNamedDeclAsString(decl), clone);
 }
 
 void ConverterRefCount::ConvertFunctionMain(

From b297deac4b7ed55685f569ba70c82280c7ebb687 Mon Sep 17 00:00:00 2001
From: Nuno Lopes <nuno.lopes@tecnico.ulisboa.pt>
Date: Thu, 17 Sep 2026 14:23:44 +0100
Subject: [PATCH 8/9] fix

---
 cpp2rust/converter/converter.cpp                 | 16 +++++-----------
 cpp2rust/converter/converter.h                   |  6 +++---
 cpp2rust/converter/models/converter_refcount.cpp |  3 ++-
 cpp2rust/cpp2rust_lib.cpp                        | 12 ++++++------
 4 files changed, 16 insertions(+), 21 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 3664536e2..afdcd0dfc 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -60,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";
@@ -72,7 +71,6 @@ std::string Converter::EmitMethodsOnPtr() {
     out += methods.impl_body;
     out += "}\n";
   }
-  return out;
 }
 
 std::string Converter::ForceGlobalInit(const clang::VarDecl *decl) {
@@ -80,27 +78,23 @@ std::string Converter::ForceGlobalInit(const clang::VarDecl *decl) {
                      GetNamedDeclAsString(decl));
 }
 
-std::string Converter::EmitGlobalInits(Model model) {
-  std::string out = model == Model::kUnsafe
-                        ? "pub unsafe fn __cpp2rust_init_globals() {\n"
-                        : "pub fn __cpp2rust_init_globals() {\n";
+void Converter::EmitGlobalInits(Model model, 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";
-  return out;
 }
 
-std::string Converter::EmitOpaqueRecords() {
-  std::string out;
+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) {
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 2dba6b3f5..9387ee749 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -52,10 +52,10 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual void EmitFilePreamble();
 
-  static std::string EmitOpaqueRecords();
-  static std::string EmitGlobalInits(Model model);
+  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);
 
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index eff715db8..8a2c27e82 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -2449,7 +2449,8 @@ void ConverterRefCount::ConvertPointerSubscript(
 }
 
 std::string ConverterRefCount::ForceGlobalInit(const clang::VarDecl *decl) {
-  return std::format("let _ = {}.with(|_| ());", GetNamedDeclAsString(decl), clone);
+  return std::format("let _ = {}.with(|_| ());", GetNamedDeclAsString(decl),
+                     clone);
 }
 
 void ConverterRefCount::ConvertFunctionMain(
diff --git a/cpp2rust/cpp2rust_lib.cpp b/cpp2rust/cpp2rust_lib.cpp
index 6e73c22d7..d936aff78 100644
--- a/cpp2rust/cpp2rust_lib.cpp
+++ b/cpp2rust/cpp2rust_lib.cpp
@@ -30,9 +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();
-  rs_code += Converter::EmitGlobalInits(model);
+  Converter::EmitOpaqueRecords(rs_code);
+  Converter::EmitMethodsOnPtr(rs_code);
+  Converter::EmitGlobalInits(model, rs_code);
   return rs_code;
 }
 
@@ -72,9 +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();
-  rs_code += Converter::EmitGlobalInits(model);
+  Converter::EmitOpaqueRecords(rs_code);
+  Converter::EmitMethodsOnPtr(rs_code);
+  Converter::EmitGlobalInits(model, rs_code);
   return rs_code;
 }
 } // namespace cpp2rust

From 30a4133122da0fa07360400da4e8f8d5233d6fac Mon Sep 17 00:00:00 2001
From: Nuno Lopes <nuno.lopes@tecnico.ulisboa.pt>
Date: Thu, 17 Sep 2026 14:30:46 +0100
Subject: [PATCH 9/9] fix

---
 cpp2rust/converter/converter.cpp               |  2 +-
 .../converter/models/converter_refcount.cpp    |  3 +--
 .../out/refcount/static_name_collision.rs      |  8 ++++----
 tests/unit/out/refcount/addr_of_global.rs      | 10 +++++-----
 tests/unit/out/refcount/array_const_init.rs    |  2 +-
 .../out/refcount/bool_condition_logical.rs     |  2 +-
 .../out/refcount/bool_condition_logical_c.rs   |  2 +-
 tests/unit/out/refcount/constructor.rs         |  2 +-
 tests/unit/out/refcount/copy_assign.rs         |  2 +-
 tests/unit/out/refcount/copy_ctor.rs           |  2 +-
 tests/unit/out/refcount/default_in_statics.rs  | 10 +++++-----
 tests/unit/out/refcount/destructor.rs          |  6 +++---
 .../refcount/enum_comparisson_in_globals.rs    |  2 +-
 .../out/refcount/enum_default_in_static.rs     |  2 +-
 tests/unit/out/refcount/enum_int_interop.rs    |  8 ++++----
 tests/unit/out/refcount/enum_int_interop_c.rs  |  8 ++++----
 tests/unit/out/refcount/fn_ptr_global.rs       |  2 +-
 tests/unit/out/refcount/fn_ptr_vtable.rs       |  2 +-
 .../global-initialization-using-global.rs      |  4 ++--
 .../out/refcount/global_init_side_effect.rs    |  6 +++---
 .../unit/out/refcount/global_non_const_init.rs | 18 +++++++++---------
 tests/unit/out/refcount/global_pointers.rs     |  6 +++---
 .../out/refcount/global_without_initializer.rs |  6 +++---
 tests/unit/out/refcount/null_in_statics.rs     | 16 ++++++++--------
 .../refcount/operator_member_pointer_member.rs |  2 +-
 tests/unit/out/refcount/rule_of_five.rs        |  6 +++---
 tests/unit/out/refcount/rule_of_three.rs       |  4 ++--
 tests/unit/out/refcount/rvalue_ref_global.rs   |  2 +-
 tests/unit/out/refcount/static_shadow.rs       |  2 +-
 tests/unit/out/refcount/static_var_in_class.rs |  4 ++--
 .../refcount/string_literal_interior_null.rs   |  2 +-
 .../out/refcount/string_literal_ptr_init.rs    |  2 +-
 tests/unit/out/refcount/void_cast.rs           |  2 +-
 33 files changed, 78 insertions(+), 79 deletions(-)

diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index afdcd0dfc..0f3134d3f 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -78,7 +78,7 @@ std::string Converter::ForceGlobalInit(const clang::VarDecl *decl) {
                      GetNamedDeclAsString(decl));
 }
 
-void Converter::EmitGlobalInits(Model model, string &out) {
+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_) {
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 8a2c27e82..cf2a6a7bc 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -2449,8 +2449,7 @@ void ConverterRefCount::ConvertPointerSubscript(
 }
 
 std::string ConverterRefCount::ForceGlobalInit(const clang::VarDecl *decl) {
-  return std::format("let _ = {}.with(|_| ());", GetNamedDeclAsString(decl),
-                     clone);
+  return std::format("let _ = {}.with(|_| ());", GetNamedDeclAsString(decl));
 }
 
 void ConverterRefCount::ConvertFunctionMain(
diff --git a/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs b/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs
index 1a5a06d8f..fecb8dd53 100644
--- a/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs
+++ b/tests/multi-file/static_name_collision/out/refcount/static_name_collision.rs
@@ -42,8 +42,8 @@ pub fn b_bar_5() -> i32 {
     return (*same_name_same_type_7.with(Value::clone).borrow());
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = same_name_different_type_0.with(Value::clone);
-    let _ = same_name_same_type_1.with(Value::clone);
-    let _ = same_name_different_type_6.with(Value::clone);
-    let _ = same_name_same_type_7.with(Value::clone);
+    let _ = same_name_different_type_0.with(|_| ());
+    let _ = same_name_same_type_1.with(|_| ());
+    let _ = same_name_different_type_6.with(|_| ());
+    let _ = same_name_same_type_7.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/addr_of_global.rs b/tests/unit/out/refcount/addr_of_global.rs
index f028004d9..5244c5fea 100644
--- a/tests/unit/out/refcount/addr_of_global.rs
+++ b/tests/unit/out/refcount/addr_of_global.rs
@@ -138,9 +138,9 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = alpha_0.with(Value::clone);
-    let _ = beta_1.with(Value::clone);
-    let _ = shared_2.with(Value::clone);
-    let _ = items_3.with(Value::clone);
-    let _ = obj_4.with(Value::clone);
+    let _ = alpha_0.with(|_| ());
+    let _ = beta_1.with(|_| ());
+    let _ = shared_2.with(|_| ());
+    let _ = items_3.with(|_| ());
+    let _ = obj_4.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/array_const_init.rs b/tests/unit/out/refcount/array_const_init.rs
index 760e2ccc2..4335228aa 100644
--- a/tests/unit/out/refcount/array_const_init.rs
+++ b/tests/unit/out/refcount/array_const_init.rs
@@ -85,5 +85,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = s_0.with(Value::clone);
+    let _ = s_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/bool_condition_logical.rs b/tests/unit/out/refcount/bool_condition_logical.rs
index 0e1e3ed66..e8995c67a 100644
--- a/tests/unit/out/refcount/bool_condition_logical.rs
+++ b/tests/unit/out/refcount/bool_condition_logical.rs
@@ -133,5 +133,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = side_effect_0.with(Value::clone);
+    let _ = side_effect_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/bool_condition_logical_c.rs b/tests/unit/out/refcount/bool_condition_logical_c.rs
index 14bbe4383..f08568c31 100644
--- a/tests/unit/out/refcount/bool_condition_logical_c.rs
+++ b/tests/unit/out/refcount/bool_condition_logical_c.rs
@@ -177,5 +177,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = side_effect_0.with(Value::clone);
+    let _ = side_effect_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/constructor.rs b/tests/unit/out/refcount/constructor.rs
index 158b73715..8f164092a 100644
--- a/tests/unit/out/refcount/constructor.rs
+++ b/tests/unit/out/refcount/constructor.rs
@@ -79,5 +79,5 @@ impl SImpl for Ptr<S> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = total_0.with(Value::clone);
+    let _ = total_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/copy_assign.rs b/tests/unit/out/refcount/copy_assign.rs
index 6057493e9..339998efb 100644
--- a/tests/unit/out/refcount/copy_assign.rs
+++ b/tests/unit/out/refcount/copy_assign.rs
@@ -311,5 +311,5 @@ impl RefQualifiedImpl for Ptr<RefQualified> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = assigns_0.with(Value::clone);
+    let _ = assigns_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/copy_ctor.rs b/tests/unit/out/refcount/copy_ctor.rs
index a43d804ea..58b0b3ca6 100644
--- a/tests/unit/out/refcount/copy_ctor.rs
+++ b/tests/unit/out/refcount/copy_ctor.rs
@@ -238,5 +238,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = copies_0.with(Value::clone);
+    let _ = copies_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/default_in_statics.rs b/tests/unit/out/refcount/default_in_statics.rs
index 614f11d66..0d2a34b81 100644
--- a/tests/unit/out/refcount/default_in_statics.rs
+++ b/tests/unit/out/refcount/default_in_statics.rs
@@ -289,9 +289,9 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = static_fn_0.with(Value::clone);
-    let _ = static_outer_1.with(Value::clone);
-    let _ = static_inner_array_2.with(Value::clone);
-    let _ = static_foo_3.with(Value::clone);
-    let _ = static_foo_array_4.with(Value::clone);
+    let _ = static_fn_0.with(|_| ());
+    let _ = static_outer_1.with(|_| ());
+    let _ = static_inner_array_2.with(|_| ());
+    let _ = static_foo_3.with(|_| ());
+    let _ = static_foo_array_4.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/destructor.rs b/tests/unit/out/refcount/destructor.rs
index 11418d29a..a4c7d87f4 100644
--- a/tests/unit/out/refcount/destructor.rs
+++ b/tests/unit/out/refcount/destructor.rs
@@ -518,7 +518,7 @@ impl Templated_int_Impl for Ptr<Templated_int_> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = global_0.with(Value::clone);
-    let _ = order_1.with(Value::clone);
-    let _ = order_count_2.with(Value::clone);
+    let _ = global_0.with(|_| ());
+    let _ = order_1.with(|_| ());
+    let _ = order_count_2.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/enum_comparisson_in_globals.rs b/tests/unit/out/refcount/enum_comparisson_in_globals.rs
index fef923ce5..94643197d 100644
--- a/tests/unit/out/refcount/enum_comparisson_in_globals.rs
+++ b/tests/unit/out/refcount/enum_comparisson_in_globals.rs
@@ -22,5 +22,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = global_0.with(Value::clone);
+    let _ = global_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/enum_default_in_static.rs b/tests/unit/out/refcount/enum_default_in_static.rs
index 6f1f4868c..a33c8fb89 100644
--- a/tests/unit/out/refcount/enum_default_in_static.rs
+++ b/tests/unit/out/refcount/enum_default_in_static.rs
@@ -55,5 +55,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = config_0.with(Value::clone);
+    let _ = config_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/enum_int_interop.rs b/tests/unit/out/refcount/enum_int_interop.rs
index fc785b20f..7037c45dc 100644
--- a/tests/unit/out/refcount/enum_int_interop.rs
+++ b/tests/unit/out/refcount/enum_int_interop.rs
@@ -236,8 +236,8 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = global_color_0.with(Value::clone);
-    let _ = global_opt_1.with(Value::clone);
-    let _ = global_tag_2.with(Value::clone);
-    let _ = entries_3.with(Value::clone);
+    let _ = global_color_0.with(|_| ());
+    let _ = global_opt_1.with(|_| ());
+    let _ = global_tag_2.with(|_| ());
+    let _ = entries_3.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/enum_int_interop_c.rs b/tests/unit/out/refcount/enum_int_interop_c.rs
index 2066c0292..5887fe630 100644
--- a/tests/unit/out/refcount/enum_int_interop_c.rs
+++ b/tests/unit/out/refcount/enum_int_interop_c.rs
@@ -299,8 +299,8 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = global_color_0.with(Value::clone);
-    let _ = global_opt_1.with(Value::clone);
-    let _ = global_tag_2.with(Value::clone);
-    let _ = entries_3.with(Value::clone);
+    let _ = global_color_0.with(|_| ());
+    let _ = global_opt_1.with(|_| ());
+    let _ = global_tag_2.with(|_| ());
+    let _ = entries_3.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/fn_ptr_global.rs b/tests/unit/out/refcount/fn_ptr_global.rs
index 39780d3c0..626d485af 100644
--- a/tests/unit/out/refcount/fn_ptr_global.rs
+++ b/tests/unit/out/refcount/fn_ptr_global.rs
@@ -54,5 +54,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = g_op_2.with(Value::clone);
+    let _ = g_op_2.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/fn_ptr_vtable.rs b/tests/unit/out/refcount/fn_ptr_vtable.rs
index 043c1d337..312ae756b 100644
--- a/tests/unit/out/refcount/fn_ptr_vtable.rs
+++ b/tests/unit/out/refcount/fn_ptr_vtable.rs
@@ -91,5 +91,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = storage_0.with(Value::clone);
+    let _ = storage_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/global-initialization-using-global.rs b/tests/unit/out/refcount/global-initialization-using-global.rs
index 2fffecc6d..0bcc707c6 100644
--- a/tests/unit/out/refcount/global-initialization-using-global.rs
+++ b/tests/unit/out/refcount/global-initialization-using-global.rs
@@ -25,6 +25,6 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = first_0.with(Value::clone);
-    let _ = second_1.with(Value::clone);
+    let _ = first_0.with(|_| ());
+    let _ = second_1.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/global_init_side_effect.rs b/tests/unit/out/refcount/global_init_side_effect.rs
index 7bada4ce5..c5ed81441 100644
--- a/tests/unit/out/refcount/global_init_side_effect.rs
+++ b/tests/unit/out/refcount/global_init_side_effect.rs
@@ -51,7 +51,7 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = total_0.with(Value::clone);
-    let _ = a_1.with(Value::clone);
-    let _ = b_2.with(Value::clone);
+    let _ = total_0.with(|_| ());
+    let _ = a_1.with(|_| ());
+    let _ = b_2.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/global_non_const_init.rs b/tests/unit/out/refcount/global_non_const_init.rs
index 666db5b01..7ea73c533 100644
--- a/tests/unit/out/refcount/global_non_const_init.rs
+++ b/tests/unit/out/refcount/global_non_const_init.rs
@@ -217,13 +217,13 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = signature_3.with(Value::clone);
-    let _ = single_4.with(Value::clone);
-    let _ = from_call_5.with(Value::clone);
-    let _ = depends_on_call_6.with(Value::clone);
-    let _ = default_ctor_7.with(Value::clone);
-    let _ = arg_ctor_8.with(Value::clone);
-    let _ = str_9.with(Value::clone);
-    let _ = inline_member_11.with(Value::clone);
-    let _ = member_10.with(Value::clone);
+    let _ = signature_3.with(|_| ());
+    let _ = single_4.with(|_| ());
+    let _ = from_call_5.with(|_| ());
+    let _ = depends_on_call_6.with(|_| ());
+    let _ = default_ctor_7.with(|_| ());
+    let _ = arg_ctor_8.with(|_| ());
+    let _ = str_9.with(|_| ());
+    let _ = inline_member_11.with(|_| ());
+    let _ = member_10.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/global_pointers.rs b/tests/unit/out/refcount/global_pointers.rs
index f560b081d..1dec7a08e 100644
--- a/tests/unit/out/refcount/global_pointers.rs
+++ b/tests/unit/out/refcount/global_pointers.rs
@@ -83,7 +83,7 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = single_entry_0.with(Value::clone);
-    let _ = entries_1.with(Value::clone);
-    let _ = arr_of_pointers_2.with(Value::clone);
+    let _ = single_entry_0.with(|_| ());
+    let _ = entries_1.with(|_| ());
+    let _ = arr_of_pointers_2.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/global_without_initializer.rs b/tests/unit/out/refcount/global_without_initializer.rs
index 9d778b8e6..4f615e31e 100644
--- a/tests/unit/out/refcount/global_without_initializer.rs
+++ b/tests/unit/out/refcount/global_without_initializer.rs
@@ -52,7 +52,7 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = s_0.with(Value::clone);
-    let _ = file_1.with(Value::clone);
-    let _ = size_2.with(Value::clone);
+    let _ = s_0.with(|_| ());
+    let _ = file_1.with(|_| ());
+    let _ = size_2.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/null_in_statics.rs b/tests/unit/out/refcount/null_in_statics.rs
index f74417e5b..3e8f2df98 100644
--- a/tests/unit/out/refcount/null_in_statics.rs
+++ b/tests/unit/out/refcount/null_in_statics.rs
@@ -64,12 +64,12 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = p_mut_0.with(Value::clone);
-    let _ = p_const_1.with(Value::clone);
-    let _ = cp_2.with(Value::clone);
-    let _ = arr_of_ptr_3.with(Value::clone);
-    let _ = pp_4.with(Value::clone);
-    let _ = const_arr_of_ptr_5.with(Value::clone);
-    let _ = cp_explicit_null_6.with(Value::clone);
-    let _ = p_zero_7.with(Value::clone);
+    let _ = p_mut_0.with(|_| ());
+    let _ = p_const_1.with(|_| ());
+    let _ = cp_2.with(|_| ());
+    let _ = arr_of_ptr_3.with(|_| ());
+    let _ = pp_4.with(|_| ());
+    let _ = const_arr_of_ptr_5.with(|_| ());
+    let _ = cp_explicit_null_6.with(|_| ());
+    let _ = p_zero_7.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/operator_member_pointer_member.rs b/tests/unit/out/refcount/operator_member_pointer_member.rs
index b91632df0..2512f5096 100644
--- a/tests/unit/out/refcount/operator_member_pointer_member.rs
+++ b/tests/unit/out/refcount/operator_member_pointer_member.rs
@@ -181,5 +181,5 @@ impl SImpl for Ptr<S> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = table_0.with(Value::clone);
+    let _ = table_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/rule_of_five.rs b/tests/unit/out/refcount/rule_of_five.rs
index 93a164766..6140a9ec6 100644
--- a/tests/unit/out/refcount/rule_of_five.rs
+++ b/tests/unit/out/refcount/rule_of_five.rs
@@ -226,7 +226,7 @@ impl BufferImpl for Ptr<Buffer> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = alive_0.with(Value::clone);
-    let _ = copies_1.with(Value::clone);
-    let _ = moves_2.with(Value::clone);
+    let _ = alive_0.with(|_| ());
+    let _ = copies_1.with(|_| ());
+    let _ = moves_2.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/rule_of_three.rs b/tests/unit/out/refcount/rule_of_three.rs
index c1835f077..e703ec8d3 100644
--- a/tests/unit/out/refcount/rule_of_three.rs
+++ b/tests/unit/out/refcount/rule_of_three.rs
@@ -188,6 +188,6 @@ impl BufferImpl for Ptr<Buffer> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = alive_0.with(Value::clone);
-    let _ = copies_1.with(Value::clone);
+    let _ = alive_0.with(|_| ());
+    let _ = copies_1.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/rvalue_ref_global.rs b/tests/unit/out/refcount/rvalue_ref_global.rs
index baec2c70f..f2739da47 100644
--- a/tests/unit/out/refcount/rvalue_ref_global.rs
+++ b/tests/unit/out/refcount/rvalue_ref_global.rs
@@ -19,5 +19,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = g_0.with(Ptr::clone);
+    let _ = g_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/static_shadow.rs b/tests/unit/out/refcount/static_shadow.rs
index 6e1b0c603..518529ff6 100644
--- a/tests/unit/out/refcount/static_shadow.rs
+++ b/tests/unit/out/refcount/static_shadow.rs
@@ -31,5 +31,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = value_0.with(Value::clone);
+    let _ = value_0.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/static_var_in_class.rs b/tests/unit/out/refcount/static_var_in_class.rs
index 6fd82f819..7f07589f9 100644
--- a/tests/unit/out/refcount/static_var_in_class.rs
+++ b/tests/unit/out/refcount/static_var_in_class.rs
@@ -67,6 +67,6 @@ impl CImpl for Ptr<C> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = inner_const_0.with(Value::clone);
-    let _ = inner_const_1.with(Value::clone);
+    let _ = inner_const_0.with(|_| ());
+    let _ = inner_const_1.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/string_literal_interior_null.rs b/tests/unit/out/refcount/string_literal_interior_null.rs
index 33fcbda7f..ee01e33c5 100644
--- a/tests/unit/out/refcount/string_literal_interior_null.rs
+++ b/tests/unit/out/refcount/string_literal_interior_null.rs
@@ -44,5 +44,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = g_packet_1.with(Value::clone);
+    let _ = g_packet_1.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/string_literal_ptr_init.rs b/tests/unit/out/refcount/string_literal_ptr_init.rs
index 06a951122..728a3a018 100644
--- a/tests/unit/out/refcount/string_literal_ptr_init.rs
+++ b/tests/unit/out/refcount/string_literal_ptr_init.rs
@@ -173,5 +173,5 @@ fn main_0() -> i32 {
     return 0;
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = table_1.with(Value::clone);
+    let _ = table_1.with(|_| ());
 }
diff --git a/tests/unit/out/refcount/void_cast.rs b/tests/unit/out/refcount/void_cast.rs
index d4614a4da..2b31ab3ad 100644
--- a/tests/unit/out/refcount/void_cast.rs
+++ b/tests/unit/out/refcount/void_cast.rs
@@ -191,5 +191,5 @@ impl NonCopyableImpl for Ptr<NonCopyable> {
     }
 }
 pub fn __cpp2rust_init_globals() {
-    let _ = side_effect_counter_3.with(Value::clone);
+    let _ = side_effect_counter_3.with(|_| ());
 }