Add missing Debuginfo to PDB debug file on windows.

Fixed CL and CMD in LF_DEBUGINFO to contain the correct information instead of empty/invalid values.

Author: nebulark

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -1,4 +1,7 @@
-use crate::back::write::{self, save_temp_bitcode, CodegenDiagnosticsStage, DiagnosticHandlers};
+use crate::back::write::{
+    self, add_cpp_args_to_target_machine, create_target_machine_args, save_temp_bitcode,
+    CodegenDiagnosticsStage, DiagnosticHandlers,
+};
 use crate::errors::{
     DynamicLinkingWithLTO, LlvmError, LtoBitcodeFromRlib, LtoDisallowed, LtoDylib,
 };
@@ -696,6 +699,8 @@ pub unsafe fn optimize_thin_module(
     let module_name = &thin_module.shared.module_names[thin_module.idx];
     let tm_factory_config = TargetMachineFactoryConfig::new(cgcx, module_name.to_str().unwrap());
     let tm = (cgcx.tm_factory)(tm_factory_config).map_err(|e| write::llvm_err(&diag_handler, e))?;
+    let tm_cpp_args = create_target_machine_args(&cgcx.expanded_args);
+    add_cpp_args_to_target_machine(tm, &*tm_cpp_args);
 
     // Right now the implementation we've got only works over serialized
     // modules, so we create a fresh new LLVM context and parse the module
@@ -705,7 +710,7 @@ pub unsafe fn optimize_thin_module(
     let llcx = llvm::LLVMRustContextCreate(cgcx.fewer_names);
     let llmod_raw = parse_module(llcx, module_name, thin_module.data(), &diag_handler)? as *const _;
     let mut module = ModuleCodegen {
-        module_llvm: ModuleLlvm { llmod_raw, llcx, tm },
+        module_llvm: ModuleLlvm { llmod_raw, llcx, tm, tm_cpp_args },
         name: thin_module.name().to_string(),
         kind: ModuleKind::Regular,
     };

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -104,6 +104,33 @@ pub fn create_informational_target_machine(sess: &Session) -> &'static mut llvm:
         .unwrap_or_else(|err| llvm_err(sess.diagnostic(), err).raise())
 }
 
+pub fn create_target_machine_args(expanded_args: &[String]) -> *mut llvm::TargetMachineCppArgs {
+    let expanded_args_cstr: Vec<CString> =
+        expanded_args.iter().map(|s| CString::new(s.as_str()).ok()).flatten().collect();
+
+    let expanded_args_cstr_ptrs: Vec<*const c_char> =
+        expanded_args_cstr.iter().map(|cstr| cstr.as_ptr()).collect();
+
+    fn path_to_cstr(os: std::path::PathBuf) -> Option<CString> {
+        let s = os.to_str()?;
+        CString::new(s).ok()
+    }
+    let exe_path: CString =
+        std::env::current_exe().ok().map(path_to_cstr).flatten().unwrap_or_default();
+
+    let exe_path_ptr = exe_path.as_ptr();
+    let expanded_args_cstr_ptrs_slice = &expanded_args_cstr_ptrs[..];
+
+    // SAFETY: Ptrs are valid, and this function does make its own copies so we are allowed to invalidate the pointers after the functions exits
+    unsafe {
+        llvm::LLVMRustCreateTargetMachineArgs(
+            exe_path_ptr,
+            expanded_args_cstr_ptrs_slice.len() as c_int,
+            expanded_args_cstr_ptrs_slice.as_ptr(),
+        )
+    }
+}
+
 pub fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> &'static mut llvm::TargetMachine {
     let split_dwarf_file = if tcx.sess.target_can_use_split_dwarf() {
         tcx.output_filenames(()).split_dwarf_path(
@@ -123,6 +150,18 @@ pub fn create_target_machine(tcx: TyCtxt<'_>, mod_name: &str) -> &'static mut ll
     .unwrap_or_else(|err| llvm_err(tcx.sess.diagnostic(), err).raise())
 }
 
+pub fn add_cpp_args_to_target_machine<'tm, 'args>(
+    tm: &'tm mut llvm::TargetMachine,
+    args: &'args llvm::TargetMachineCppArgs,
+) where
+    'args: 'tm,
+{
+    // SAFETY: args lives at least as long tm
+    unsafe {
+        llvm::LLVMRustAddCppArgsRefToTargetMachine(tm, args);
+    }
+}
+
 pub fn to_llvm_opt_settings(
     cfg: config::OptLevel,
 ) -> (llvm::CodeGenOptLevel, llvm::CodeGenOptSize) {

compiler/rustc_codegen_llvm/src/lib.rs

@@ -21,7 +21,10 @@ extern crate rustc_macros;
 #[macro_use]
 extern crate tracing;
 
-use back::write::{create_informational_target_machine, create_target_machine};
+use back::write::{
+    add_cpp_args_to_target_machine, create_informational_target_machine, create_target_machine,
+    create_target_machine_args,
+};
 
 use errors::ParseTargetMachineConfig;
 pub use llvm_util::target_features;
@@ -412,6 +415,7 @@ impl CodegenBackend for LlvmCodegenBackend {
 pub struct ModuleLlvm {
     llcx: &'static mut llvm::Context,
     llmod_raw: *const llvm::Module,
+    tm_cpp_args: *mut llvm::TargetMachineCppArgs,
     tm: &'static mut llvm::TargetMachine,
 }
 
@@ -423,15 +427,21 @@ impl ModuleLlvm {
         unsafe {
             let llcx = llvm::LLVMRustContextCreate(tcx.sess.fewer_names());
             let llmod_raw = context::create_module(tcx, llcx, mod_name) as *const _;
-            ModuleLlvm { llmod_raw, llcx, tm: create_target_machine(tcx, mod_name) }
+            let tm_cpp_args = create_target_machine_args(&tcx.sess.expanded_args);
+            let tm = create_target_machine(tcx, mod_name);
+            add_cpp_args_to_target_machine(tm, &*tm_cpp_args);
+            ModuleLlvm { llmod_raw, llcx, tm, tm_cpp_args }
         }
     }
 
     fn new_metadata(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
             let llcx = llvm::LLVMRustContextCreate(tcx.sess.fewer_names());
             let llmod_raw = context::create_module(tcx, llcx, mod_name) as *const _;
-            ModuleLlvm { llmod_raw, llcx, tm: create_informational_target_machine(tcx.sess) }
+            let tm_cpp_args = create_target_machine_args(&tcx.sess.expanded_args);
+            let tm = create_informational_target_machine(tcx.sess);
+            add_cpp_args_to_target_machine(tm, &*tm_cpp_args);
+            ModuleLlvm { llmod_raw, llcx, tm, tm_cpp_args }
         }
     }
 
@@ -451,8 +461,10 @@ impl ModuleLlvm {
                     return Err(handler.emit_almost_fatal(ParseTargetMachineConfig(e)));
                 }
             };
+            let tm_cpp_args = create_target_machine_args(&cgcx.expanded_args);
+            add_cpp_args_to_target_machine(tm, &*tm_cpp_args);
 
-            Ok(ModuleLlvm { llmod_raw, llcx, tm })
+            Ok(ModuleLlvm { llmod_raw, llcx, tm, tm_cpp_args })
         }
     }
 
@@ -465,6 +477,7 @@ impl Drop for ModuleLlvm {
     fn drop(&mut self) {
         unsafe {
             llvm::LLVMRustDisposeTargetMachine(&mut *(self.tm as *mut _));
+            llvm::LLVMRustDisposeTargetMachineArgs(self.tm_cpp_args);
             llvm::LLVMContextDispose(&mut *(self.llcx as *mut _));
         }
     }

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -655,6 +655,19 @@ pub struct PassManager<'a>(InvariantOpaque<'a>);
 extern "C" {
     pub type Pass;
 }
+
+extern "C" {
+    pub type TargetMachineCppArgs;
+}
+
+// SAFETY: TargetMachineCppArgs is equivalent to the following, which is Send + Sync
+// struct LLVMTargetMachineCppArgs {
+//     CompilerPath : String,
+//     OtherArgs : Vec<String>,
+// };
+unsafe impl Send for TargetMachineCppArgs {}
+unsafe impl Sync for TargetMachineCppArgs {}
+
 extern "C" {
     pub type TargetMachine;
 }
@@ -2298,6 +2311,15 @@ extern "C" {
     );
 
     pub fn LLVMRustGetHostCPUName(len: *mut usize) -> *const c_char;
+
+    pub fn LLVMRustCreateTargetMachineArgs(
+        CompilerPath: *const c_char,
+        OtherArgc: c_int,
+        OtherArgv: *const *const c_char,
+    ) -> *mut TargetMachineCppArgs;
+
+    pub fn LLVMRustDisposeTargetMachineArgs(Args: *mut TargetMachineCppArgs);
+
     pub fn LLVMRustCreateTargetMachine(
         Triple: *const c_char,
         CPU: *const c_char,
@@ -2319,7 +2341,15 @@ extern "C" {
         SplitDwarfFile: *const c_char,
         ForceEmulatedTls: bool,
     ) -> Option<&'static mut TargetMachine>;
+
     pub fn LLVMRustDisposeTargetMachine(T: &'static mut TargetMachine);
+
+    pub fn LLVMRustAddCppArgsRefToTargetMachine<'tm, 'args>(
+        tm: &'tm mut TargetMachine,
+        args: &'args TargetMachineCppArgs,
+    ) where
+        'args: 'tm;
+
     pub fn LLVMRustAddLibraryInfo<'a>(
         PM: &PassManager<'a>,
         M: &'a Module,

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -342,6 +342,12 @@ pub struct CodegenContext<B: WriteBackendMethods> {
     pub split_debuginfo: rustc_target::spec::SplitDebuginfo,
     pub split_dwarf_kind: rustc_session::config::SplitDwarfKind,
 
+    /// All commandline args used to invoke the compiler, with @file args fully expanded.
+    /// This will only be used within debug info, e.g. in the pdb file on windows
+    /// This is mainly useful for other tools that reads that debuginfo to figure out
+    /// how to call the compiler with the same arguments.
+    pub expanded_args: Vec<String>,
+
     /// Handler to use for diagnostics produced during codegen.
     pub diag_emitter: SharedEmitter,
     /// LLVM optimizations for which we want to print remarks.
@@ -1093,6 +1099,7 @@ fn start_executing_work<B: ExtraBackendMethods>(
         incr_comp_session_dir: sess.incr_comp_session_dir_opt().map(|r| r.clone()),
         cgu_reuse_tracker: sess.cgu_reuse_tracker.clone(),
         coordinator_send,
+        expanded_args: tcx.sess.expanded_args.clone(),
         diag_emitter: shared_emitter.clone(),
         output_filenames: tcx.output_filenames(()).clone(),
         regular_module_config: regular_config,

compiler/rustc_driver_impl/src/lib.rs

@@ -312,6 +312,7 @@ fn run_compiler(
         override_queries: None,
         make_codegen_backend,
         registry: diagnostics_registry(),
+        expanded_args: args,
     };
 
     match make_input(&early_error_handler, &matches.free) {

compiler/rustc_interface/src/interface.rs

@@ -279,6 +279,12 @@ pub struct Config {
 
     /// Registry of diagnostics codes.
     pub registry: Registry,
+
+    /// All commandline args used to invoke the compiler, with @file args fully expanded.
+    /// This will only be used within debug info, e.g. in the pdb file on windows
+    /// This is mainly useful for other tools that reads that debuginfo to figure out
+    /// how to call the compiler with the same arguments.
+    pub expanded_args: Vec<String>,
 }
 
 // JUSTIFICATION: before session exists, only config
@@ -317,6 +323,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
                 config.make_codegen_backend,
                 registry.clone(),
                 config.ice_file,
+                config.expanded_args,
             );
 
             if let Some(parse_sess_created) = config.parse_sess_created {

compiler/rustc_interface/src/tests.rs

@@ -68,6 +68,7 @@ fn mk_session(handler: &mut EarlyErrorHandler, matches: getopts::Matches) -> (Se
         None,
         "",
         None,
+        Default::default(),
     );
     (sess, cfg)
 }

compiler/rustc_interface/src/util.rs

@@ -71,6 +71,7 @@ pub fn create_session(
     >,
     descriptions: Registry,
     ice_file: Option<PathBuf>,
+    expanded_args: Vec<String>,
 ) -> (Session, Box<dyn CodegenBackend>) {
     let codegen_backend = if let Some(make_codegen_backend) = make_codegen_backend {
         make_codegen_backend(&sopts)
@@ -113,6 +114,7 @@ pub fn create_session(
         target_override,
         rustc_version_str().unwrap_or("unknown"),
         ice_file,
+        expanded_args,
     );
 
     codegen_backend.init(&sess);

compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp

@@ -50,6 +50,11 @@
 
 using namespace llvm;
 
+struct LLVMTargetMachineCppArgs {
+  std::string CompilerPath;
+  std::vector<std::string> OtherArgs;
+};
+
 typedef struct LLVMOpaquePass *LLVMPassRef;
 typedef struct LLVMOpaqueTargetMachine *LLVMTargetMachineRef;
 
@@ -387,9 +392,28 @@ extern "C" const char* LLVMRustGetHostCPUName(size_t *len) {
   return Name.data();
 }
 
+extern "C" LLVMTargetMachineCppArgs* LLVMRustCreateTargetMachineArgs(const char * CompilerPath,
+                                                int OtherArgc,
+                                                const char *const *OtherArgv) {
+  LLVMTargetMachineCppArgs* args = new LLVMTargetMachineCppArgs;
+  args->CompilerPath = std::string(CompilerPath);
+  args->OtherArgs.reserve(OtherArgc);
+  for (int i = 0; i < OtherArgc; ++i)
+  {
+    args->OtherArgs.push_back(std::string(OtherArgv[i]));
+  }
+
+  return args;
+}
+
+extern "C" void LLVMRustDisposeTargetMachineArgs(LLVMTargetMachineCppArgs* Args) {
+  delete Args;
+}
+
 extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
     const char *TripleStr, const char *CPU, const char *Feature,
-    const char *ABIStr, LLVMRustCodeModel RustCM, LLVMRustRelocModel RustReloc,
+    const char *ABIStr,
+    LLVMRustCodeModel RustCM, LLVMRustRelocModel RustReloc,
     LLVMRustCodeGenOptLevel RustOptLevel, bool UseSoftFloat,
     bool FunctionSections,
     bool DataSections,
@@ -428,6 +452,7 @@ extern "C" LLVMTargetMachineRef LLVMRustCreateTargetMachine(
   Options.MCOptions.AsmVerbose = AsmComments;
   Options.MCOptions.PreserveAsmComments = AsmComments;
   Options.MCOptions.ABIName = ABIStr;
+
   if (SplitDwarfFile) {
       Options.MCOptions.SplitDwarfFile = SplitDwarfFile;
   }
@@ -466,6 +491,13 @@ extern "C" void LLVMRustDisposeTargetMachine(LLVMTargetMachineRef TM) {
   delete unwrap(TM);
 }
 
+extern "C" void LLVMRustAddCppArgsRefToTargetMachine(LLVMTargetMachineRef TM,
+                                                  LLVMTargetMachineCppArgs* TargetMachineCppArgs) {
+    unwrap(TM)->Options.MCOptions.Argv0 = TargetMachineCppArgs->CompilerPath.c_str();
+    unwrap(TM)->Options.MCOptions.CommandLineArgs =
+      llvm::ArrayRef<std::string>(TargetMachineCppArgs->OtherArgs);
+}
+
 // Unfortunately, the LLVM C API doesn't provide a way to create the
 // TargetLibraryInfo pass, so we use this method to do so.
 extern "C" void LLVMRustAddLibraryInfo(LLVMPassManagerRef PMR, LLVMModuleRef M,
@@ -489,6 +521,8 @@ extern "C" void LLVMRustSetLLVMOptions(int Argc, char **Argv) {
   cl::ParseCommandLineOptions(Argc, Argv);
 }
 
+
+
 enum class LLVMRustFileType {
   AssemblyFile,
   ObjectFile,