Debug global variable not initialized bug

antoyo · antoyo · commit 747924ad86b6 · 2025-01-11T10:41:27.000-05:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/build_system/src/build.rs b/build_system/src/build.rs
@@ -130,6 +130,7 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
     if config.no_default_features {
         rustflags.push_str(" -Csymbol-mangling-version=v0");
     }
+    rustflags.push_str(" --print link-args");
 
     let mut args: Vec<&dyn AsRef<OsStr>> = vec![&"cargo", &"build", &"--target", &config.target];
     for feature in &config.features {
@@ -156,7 +157,19 @@ pub fn build_sysroot(env: &HashMap<String, String>, config: &ConfigInfo) -> Resu
     }
 
     let mut env = env.clone();
+    /*rustflags.push_str(" -C link-arg=-Wl,--verbose");
+    rustflags.push_str(" -C link-arg=-Wl,--warn-ifunc-textrel");
+    rustflags.push_str(" -C link-arg=-Wl,--warn-unresolved-symbols");
+    rustflags.push_str(" -C link-arg=-Wl,--fatal-warnings");
+    rustflags.push_str(" -C link-arg=-Wl,--warn-backrefs");
+    rustflags.push_str(" -C link-arg=-Wl,-znotext");
+    //rustflags.push_str(" -C link-arg=-Wl,--emit-relocs");
+    //rustflags.push_str(" -C link-arg=-Wl,--trace-symbol=memchr::arch::x86_64::memchr::memchr_raw::FN");
+    //rustflags.push_str(" -C link-arg=-Wl,--trace-symbol=_ZN6memchr4arch6x86_646memchr10memchr_raw2FN17haaf621f7b8ca567eE");
+    //rustflags.push_str(" -C link-arg=-Wl,--print-map");
+    //rustflags.push_str(" -C link-arg=-Wl,");
     env.insert("RUSTFLAGS".to_string(), rustflags);
+    env.insert("RUSTC_LOG".to_string(), "rustc_codegen_ssa::back::link=info".to_string());*/
     run_command_with_output_and_env(&args, Some(&start_dir), Some(&env))?;
 
     // Copy files to sysroot
diff --git a/build_system/src/test.rs b/build_system/src/test.rs
@@ -692,7 +692,24 @@ fn test_libcore(env: &Env, args: &TestArg) -> Result<(), String> {
     println!("[TEST] libcore");
     let path = get_sysroot_dir().join("sysroot_src/library/core/tests");
     let _ = remove_dir_all(path.join("target"));
-    run_cargo_command(&[&"test"], Some(&path), env, args)?;
+    let mut env = env.clone();
+    env.insert("RUSTC_LOG".to_string(), "rustc_codegen_ssa::back::link=info".to_string());
+    let rustflags =
+        env.entry("RUSTFLAGS".to_string())
+        .or_default();
+    rustflags.push_str(" -C link-arg=-Wl,--verbose");
+    rustflags.push_str(" -C link-arg=-Wl,--warn-ifunc-textrel");
+    rustflags.push_str(" -C link-arg=-Wl,--warn-unresolved-symbols");
+    rustflags.push_str(" -C link-arg=-Wl,--fatal-warnings");
+    rustflags.push_str(" -C link-arg=-Wl,--warn-backrefs");
+    rustflags.push_str(" -C link-arg=-Wl,-znotext");
+    rustflags.push_str(" -C link-arg=-Wl,--emit-relocs");
+    rustflags.push_str(" -C link-arg=-Wl,--trace-symbol=memchr::arch::x86_64::memchr::memchr_raw::FN");
+    // FIXME FIXME: seems like RUSTFLAGS is not set here.
+    //rustflags.push_str(" -C link-arg=-Wl,--trace-symbol=_ZN6memchr4arch6x86_646memchr10memchr_raw2FN17haaf621f7b8ca567eE");
+    //rustflags.push_str(" -C link-arg=-Wl,--print-map");
+    //rustflags.push_str(" -Clink-arg=-not-an-arg");
+    run_cargo_command(&[&"test"], Some(&path), &env, args)?;
     Ok(())
 }
 
diff --git a/src/back/write.rs b/src/back/write.rs
@@ -1,6 +1,6 @@
 use std::{env, fs};
 
-use gccjit::OutputKind;
+use gccjit::{Context, OutputKind};
 use rustc_codegen_ssa::back::link::ensure_removed;
 use rustc_codegen_ssa::back::write::{BitcodeSection, CodegenContext, EmitObj, ModuleConfig};
 use rustc_codegen_ssa::{CompiledModule, ModuleCodegen};
@@ -34,6 +34,11 @@ pub(crate) unsafe fn codegen(
         // TODO: remove this environment variable.
         let fat_lto = env::var("EMBED_LTO_BITCODE").as_deref() == Ok("1");
 
+        if cgcx.msvc_imps_needed {
+            println!("************************************************** Imps needed");
+            create_msvc_imps(cgcx, context);
+        }
+
         let bc_out = cgcx.output_filenames.temp_path(OutputType::Bitcode, module_name);
         let obj_out = cgcx.output_filenames.temp_path(OutputType::Object, module_name);
 
@@ -196,3 +201,39 @@ pub(crate) fn save_temp_bitcode(
         llvm::LLVMWriteBitcodeToFile(llmod, cstr.as_ptr());
     }*/
 }
+
+fn create_msvc_imps<'gcc>(
+    cgcx: &CodegenContext<GccCodegenBackend>,
+    context: &Context<'gcc>,
+) {
+    if !cgcx.msvc_imps_needed {
+        return;
+    }
+    // The x86 ABI seems to require that leading underscores are added to symbol
+    // names, so we need an extra underscore on x86. There's also a leading
+    // '\x01' here which disables LLVM's symbol mangling (e.g., no extra
+    // underscores added in front).
+    let prefix = if cgcx.target_arch == "x86" { "\x01__imp__" } else { "\x01__imp_" };
+
+    /*unsafe {
+        let ptr_ty = Type::ptr_llcx(llcx);
+        let globals = base::iter_globals(llmod)
+            .filter(|&val| {
+                llvm::get_linkage(val) == llvm::Linkage::ExternalLinkage
+                    && llvm::LLVMIsDeclaration(val) == 0
+            })
+            .map(move |(val, name)| {
+                let mut imp_name = prefix.as_bytes().to_vec();
+                imp_name.extend(name);
+                let imp_name = CString::new(imp_name).unwrap();
+                (imp_name, val)
+            })
+            .collect::<Vec<_>>();
+
+        for (imp_name, val) in globals {
+            let imp = llvm::LLVMAddGlobal(llmod, ptr_ty, imp_name.as_ptr());
+            llvm::LLVMSetInitializer(imp, val);
+            llvm::set_linkage(imp, llvm::Linkage::ExternalLinkage);
+        }
+    }*/
+}
diff --git a/src/common.rs b/src/common.rs
@@ -247,7 +247,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                 if !matches!(layout.primitive(), Pointer(_)) {
                     self.const_bitcast(ptr.dereference(None).to_rvalue(), ty)
                 } else {
-                    self.const_bitcast(ptr, ty)
+                    self.context.new_cast(None, ptr, ty)
                 }
             }
         }
diff --git a/src/consts.rs b/src/consts.rs
@@ -1,6 +1,6 @@
 #[cfg(feature = "master")]
 use gccjit::{FnAttribute, VarAttribute, Visibility};
-use gccjit::{Function, GlobalKind, LValue, RValue, ToRValue, Type};
+use gccjit::{Function, FunctionType, GlobalKind, LValue, RValue, ToRValue, Type};
 use rustc_codegen_ssa::traits::{
     BaseTypeCodegenMethods, ConstCodegenMethods, StaticCodegenMethods,
 };
@@ -92,7 +92,84 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
         }
         set_global_alignment(self, global, alloc.align);
 
-        global.global_set_initializer_rvalue(value);
+
+        // TODO: if I still use this code, find the name of the variable in a better way (using
+        // def_id).
+        let var_name = format!("{:?}", global);
+        if var_name.contains("FN") && var_name.contains("memchr") {
+            println!("Var name: {:?}", var_name);
+
+            let ptr_type = value.get_type().make_pointer();
+
+            // TODO: remove \x01
+            //let prefix = if self.cgcx.target_arch == "x86" { "\x01__imp__" } else { "\x01__imp_" };
+            let prefix = "__imp__";
+            let mut imp_name = prefix.to_string();
+            imp_name.push_str(&var_name);
+
+            // FIXME: if I understand correctly the code in cg_llvm, the kind should be Imported.
+            /*let imp_global = self.context.new_global(None, GlobalKind::Exported, ptr_type, &imp_name);
+            imp_global.global_set_initializer_rvalue(global.get_address(None));*/
+
+            /*
+            /*let context = gccjit::Context::default();
+            let global = context.new_global(None, GlobalKind::Exported, val_llty, &var_name);
+            global.global_set_initializer_rvalue(value);
+            context.compile_to_file(gccjit::OutputKind::ObjectFile, format!("{}.o", var_name));*/
+
+            let void_type = self.context.new_type::<()>();
+            let fn_ptr_type = self.context.new_function_pointer_type(None, void_type, &[], false);
+            let my_name = format!("MY_NAME${}", var_name);
+            //let global = self.context.new_global(None, GlobalKind::Exported, fn_ptr_type, my_name);
+            //global.add_attribute(VarAttribute::Used);
+            println!("{:?} = {:?}", var_name, value);
+
+            let my_func_name = format!("MY_FUNC${}", var_name);
+            let func = self.context.new_function(None, FunctionType::Exported, void_type, &[], &my_func_name, false);
+            func.add_attribute(FnAttribute::Used);
+            let block = func.new_block("start");
+            block.end_with_void_return(None);
+
+            //let func = self.context.new_function(None, FunctionType::Extern, void_type, &[], "puts", false);
+            let value = func.get_address(None);
+            //let global = self.context.new_global(None, GlobalKind::Exported, value.get_type(), my_name);
+            //let value = self.context.new_bitcast(None, func.get_address(None), fn_ptr_type);
+            /*
+             * TODO: Check if the hard-coded function has the correct name.
+             * ===> It seems so.
+             * TODO: try with a function we know exists.
+             * ===> It doesn't seem to help.
+             * TODO: check if the .o contains the value (before linking into the .so).
+             * ===> It seems the object file doesn't contain the value either.
+             * ======> This is because there are relocations.
+             * TODO: check if fold in GCC erases the value.
+             * ===> It doesn't seem so.
+             *
+             * TODO TODO: try again this code with using the used attribute.
+             */
+
+            /*let var_type = global.to_rvalue().get_type();
+            let struct_type = var_type.is_struct().unwrap();
+            /*let field1_type = struct_type.get_field(0).get_type();
+            let field2_type = struct_type.get_field(1).get_type();*/
+
+            let field1 = value;
+            let field2 = self.context.new_rvalue_zero(self.int_type);
+
+            let struct_val = self.context.new_struct_constructor(None, var_type, None, &[field1, field2]);
+            let value = struct_val;*/
+
+            //let value = self.context.new_bitcast(None, func.get_address(None), val_llty);
+
+            //let value = self.context.new_rvalue_from_int(self.usize_type, 10293);
+            //let value = self.context.new_cast(None, value, fn_ptr_type); // WORKS
+            //let value = self.context.new_bitcast(None, value, fn_ptr_type); // Also WORKS
+            let value = self.context.new_bitcast(None, value, val_llty);*/
+            global.global_set_initializer_rvalue(value);
+        }
+        else {
+            global.global_set_initializer_rvalue(value);
+        }
 
         // As an optimization, all shared statics which do not have interior
         // mutability are placed into read-only memory.

Original file line number	Diff line number	Diff line change
`@@ -247,7 +247,7 @@ impl<'gcc, 'tcx> ConstCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {`
`247`	`247`	`if !matches!(layout.primitive(), Pointer(_)) {`
`248`	`248`	`self.const_bitcast(ptr.dereference(None).to_rvalue(), ty)`
`249`	`249`	`} else {`
`250`		`- self.const_bitcast(ptr, ty)`
	`250`	`+ self.context.new_cast(None, ptr, ty)`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`	`}`