Fix to avoid having to update the hash in variable names hack manually

Author: antoyo

src/base.rs

@@ -92,7 +92,7 @@ pub fn compile_codegen_unit<'tcx>(tcx: TyCtxt<'tcx>, cgu_name: Symbol) -> (Modul
                 block.end_with_void_return(None);
             });
 
-            println!("module_codegen: {:?} {:?}", cgu_name, &cx.context as *const _);
+            //println!("module_codegen: {:?} {:?}", cgu_name, &cx.context as *const _);
             let mono_items = cgu.items_in_deterministic_order(tcx);
             for &(mono_item, (linkage, visibility)) in &mono_items {
                 mono_item.predefine::<Builder<'_, '_, '_>>(&cx, linkage, visibility);

src/consts.rs

@@ -106,7 +106,6 @@ impl<'gcc, 'tcx> StaticMethods for CodegenCx<'gcc, 'tcx> {
                 else {
                     // If we created the global with the wrong type,
                     // correct the type.
-                    let name = self.get_global_name(global).expect("global name");
                     /*let name = llvm::get_value_name(global).to_vec();
                     llvm::set_value_name(global, b"");
 
@@ -141,7 +140,7 @@ impl<'gcc, 'tcx> StaticMethods for CodegenCx<'gcc, 'tcx> {
                 ARGC,
                 ARGV,
             ];
-            if !skip_init.contains(&name) {
+            if !skip_init.iter().any(|symbol_name| name.starts_with(symbol_name)) {
                 // TODO: switch to set_initializer when libgccjit supports that.
                 let memcpy = self.context.get_builtin_function("memcpy");
                 let dst = self.context.new_cast(None, global, self.type_i8p());

src/context.rs

@@ -99,6 +99,9 @@ pub struct CodegenCx<'gcc, 'tcx> {
     /// Cache of emitted const globals (value -> global)
     pub const_globals: RefCell<FxHashMap<RValue<'gcc>, RValue<'gcc>>>,
 
+    pub init_argv_var: RefCell<String>,
+    pub argv_initialized: Cell<bool>,
+
     /// Cache of constant strings,
     pub const_cstr_cache: RefCell<FxHashMap<Symbol, LValue<'gcc>>>,
 
@@ -227,6 +230,8 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
             instances: Default::default(),
             vtables: Default::default(),
             const_globals: Default::default(),
+            init_argv_var: RefCell::new(String::new()),
+            argv_initialized: Cell::new(false),
             const_cstr_cache: Default::default(),
             global_names: Default::default(),
             globals: Default::default(),
@@ -254,6 +259,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         }
     }
 
+    // TODO: remove this method and global_names.
     pub fn get_global_name(&self, value: RValue<'gcc>) -> Option<String> {
         self.global_names.borrow().get(&value).cloned()
     }

src/declare.rs

@@ -3,6 +3,7 @@ use rustc_codegen_ssa::traits::BaseTypeMethods;
 use rustc_middle::ty::Ty;
 use rustc_span::Symbol;
 use rustc_target::abi::call::FnAbi;
+use rustc_symbol_mangling::symbol_name_for_instance_in_crate;
 
 use crate::abi::FnAbiGccExt;
 use crate::context::{CodegenCx, unit_name};
@@ -53,19 +54,17 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
 
     pub fn declare_global(&self, name: &str, ty: Type<'gcc>, is_tls: bool, link_section: Option<Symbol>) -> RValue<'gcc> {
         //debug!("declare_global(name={:?})", name);
-        let mut initializer = None;
-        // NOTE: hack to initialize ARGC_INIT_ARRAY before libc tries to call the function it
-        // points to.
         // FIXME: correctly support global variable initialization.
-        if name == ARGV_INIT_ARRAY {
-            let return_type = self.type_void();
-            let params = [
-                self.context.new_parameter(None, self.int_type, "argc"),
-                self.context.new_parameter(None, self.u8_type.make_pointer().make_pointer(), "argv"),
-                self.context.new_parameter(None, self.u8_type.make_pointer().make_pointer(), "envp"),
-            ];
-            let function = self.context.new_function(None, FunctionType::Extern, return_type, &params, ARGV_INIT_WRAPPER, false);
-            initializer = Some(function.get_address(None));
+        if name.starts_with(ARGV_INIT_ARRAY) {
+            // NOTE: hack to avoid having to update the names in mangled_std_symbols: we save the
+            // name of the variable now to actually declare it later.
+            *self.init_argv_var.borrow_mut() = name.to_string();
+
+            let global = self.context.new_global(None, GlobalKind::Imported, ty, name);
+            if let Some(link_section) = link_section {
+                global.set_link_section(&link_section.as_str());
+            }
+            return global.get_address(None);
         }
         let global = self.context.new_global(None, GlobalKind::Exported, ty, name);
         if is_tls {
@@ -74,9 +73,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         if let Some(link_section) = link_section {
             global.set_link_section(&link_section.as_str());
         }
-        if let Some(initializer) = initializer {
-            global.global_set_initializer_value(initializer);
-        }
         let global = global.get_address(None);
         self.globals.borrow_mut().insert(name.to_string(), global);
         // NOTE: global seems to only be global in a module. So save the name instead of the value
@@ -100,6 +96,38 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
     }
 
     pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> RValue<'gcc> {
+        // NOTE: hack to avoid having to update the names in mangled_std_symbols: we found the name
+        // of the variable earlier, so we declare it now.
+        // Since we don't correctly support initializers yet, we initialize this variable manually
+        // for now.
+        if name.starts_with(ARGV_INIT_WRAPPER) && !self.argv_initialized.get() {
+            let global_name = &*self.init_argv_var.borrow();
+            let return_type = self.type_void();
+            let params = [
+                self.context.new_parameter(None, self.int_type, "argc"),
+                self.context.new_parameter(None, self.u8_type.make_pointer().make_pointer(), "argv"),
+                self.context.new_parameter(None, self.u8_type.make_pointer().make_pointer(), "envp"),
+            ];
+            let function = self.context.new_function(None, FunctionType::Extern, return_type, &params, name, false);
+            let initializer = function.get_address(None);
+
+            let param_types = [
+                self.int_type,
+                self.u8_type.make_pointer().make_pointer(),
+                self.u8_type.make_pointer().make_pointer(),
+            ];
+            let ty = self.context.new_function_pointer_type(None, return_type, &param_types, false);
+
+            let global = self.context.new_global(None, GlobalKind::Exported, ty, global_name);
+            global.set_link_section(".init_array.00099");
+            global.global_set_initializer_value(initializer);
+            let global = global.get_address(None);
+            self.globals.borrow_mut().insert(global_name.to_string(), global);
+            // NOTE: global seems to only be global in a module. So save the name instead of the value
+            // to import it later.
+            self.global_names.borrow_mut().insert(global, global_name.to_string());
+            self.argv_initialized.set(true);
+        }
         //debug!("declare_rust_fn(name={:?}, fn_abi={:?})", name, fn_abi);
         let (return_type, params, variadic) = fn_abi.gcc_type(self);
         let func = declare_raw_fn(self, name, () /*fn_abi.llvm_cconv()*/, return_type, &params, variadic);

src/mangled_std_symbols.rs

@@ -1,4 +1,4 @@
-pub const ARGV_INIT_ARRAY: &str = "_ZN3std3sys4unix4args3imp15ARGV_INIT_ARRAY17h60e5c750c1dd807cE";
-pub const ARGV_INIT_WRAPPER: &str = "_ZN3std3sys4unix4args3imp15ARGV_INIT_ARRAY12init_wrapper17h3768020202ef2bb7E";
-pub const ARGC: &str = "_ZN3std3sys4unix4args3imp4ARGC17h5ff1230607524ec2E";
-pub const ARGV: &str = "_ZN3std3sys4unix4args3imp4ARGV17hf68828ed70415113E";
+pub const ARGV_INIT_ARRAY: &str = "_ZN3std3sys4unix4args3imp15ARGV_INIT_ARRAY";
+pub const ARGV_INIT_WRAPPER: &str = "_ZN3std3sys4unix4args3imp15ARGV_INIT_ARRAY12init_wrapper";
+pub const ARGC: &str = "_ZN3std3sys4unix4args3imp4ARGC";
+pub const ARGV: &str = "_ZN3std3sys4unix4args3imp4ARGV";