compiletest/runtest/

debuginfo.rs

use std::ffi::{OsStr, OsString};
use std::io::{BufRead, BufReader};
use std::process::{Command, Output, Stdio};

use camino::Utf8Path;
use tracing::debug;

use super::debugger::DebuggerCommands;
use super::{Debugger, Emit, ProcRes, TestCx, Truncated, WillExecute};
use crate::debuggers::extract_gdb_version;

impl TestCx<'_> {
    pub(super) fn run_debuginfo_test(&self) {
        match self.config.debugger.unwrap() {
            Debugger::Cdb => self.run_debuginfo_cdb_test(),
            Debugger::Gdb => self.run_debuginfo_gdb_test(),
            Debugger::Lldb => self.run_debuginfo_lldb_test(),
        }
    }

    fn run_debuginfo_cdb_test(&self) {
        let exe_file = self.make_exe_name();

        // Existing PDB files are update in-place. When changing the debuginfo
        // the compiler generates for something, this can lead to the situation
        // where both the old and the new version of the debuginfo for the same
        // type is present in the PDB, which is very confusing.
        // Therefore we delete any existing PDB file before compiling the test
        // case.
        // FIXME: If can reliably detect that MSVC's link.exe is used, then
        //        passing `/INCREMENTAL:NO` might be a cleaner way to do this.
        let pdb_file = exe_file.with_extension(".pdb");
        if pdb_file.exists() {
            std::fs::remove_file(pdb_file).unwrap();
        }

        // compile test file (it should have 'compile-flags:-g' in the directive)
        let should_run = self.run_if_enabled();
        let compile_result = self.compile_test(should_run, Emit::None);
        if !compile_result.status.success() {
            self.fatal_proc_rec("compilation failed!", &compile_result);
        }
        if let WillExecute::Disabled = should_run {
            return;
        }

        // Parse debugger commands etc from test files
        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "cdb", self.revision)
            .unwrap_or_else(|e| self.fatal(&e));

        // https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-commands
        let mut script_str = String::with_capacity(2048);
        script_str.push_str("version\n"); // List CDB (and more) version info in test output
        script_str.push_str(".nvlist\n"); // List loaded `*.natvis` files, bulk of custom MSVC debug

        // If a .js file exists next to the source file being tested, then this is a JavaScript
        // debugging extension that needs to be loaded.
        let mut js_extension = self.testpaths.file.clone();
        js_extension.set_extension("cdb.js");
        if js_extension.exists() {
            script_str.push_str(&format!(".scriptload \"{}\"\n", js_extension));
        }

        // Set breakpoints on every line that contains the string "#break"
        let source_file_name = self.testpaths.file.file_name().unwrap();
        for line in &dbg_cmds.breakpoint_lines {
            script_str.push_str(&format!("bp `{}:{}`\n", source_file_name, line));
        }

        // Append the other `cdb-command:`s
        for line in &dbg_cmds.commands {
            script_str.push_str(line);
            script_str.push('\n');
        }

        script_str.push_str("qq\n"); // Quit the debugger (including remote debugger, if any)

        // Write the script into a file
        debug!("script_str = {}", script_str);
        self.dump_output_file(&script_str, "debugger.script");
        let debugger_script = self.make_out_name("debugger.script");

        let cdb_path = &self.config.cdb.as_ref().unwrap();
        let mut cdb = Command::new(cdb_path);
        cdb.arg("-lines") // Enable source line debugging.
            .arg("-cf")
            .arg(&debugger_script)
            .arg(&exe_file);

        let debugger_run_result = self.compose_and_run(
            cdb,
            self.config.target_run_lib_path.as_path(),
            None, // aux_path
            None, // input
        );

        if !debugger_run_result.status.success() {
            self.fatal_proc_rec("Error while running CDB", &debugger_run_result);
        }

        if let Err(e) = dbg_cmds.check_output(&debugger_run_result) {
            self.fatal_proc_rec(&e, &debugger_run_result);
        }
    }

    fn run_debuginfo_gdb_test(&self) {
        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "gdb", self.revision)
            .unwrap_or_else(|e| self.fatal(&e));
        let mut cmds = dbg_cmds.commands.join("\n");

        // compile test file (it should have 'compile-flags:-g' in the directive)
        let should_run = self.run_if_enabled();
        let compiler_run_result = self.compile_test(should_run, Emit::None);
        if !compiler_run_result.status.success() {
            self.fatal_proc_rec("compilation failed!", &compiler_run_result);
        }
        if let WillExecute::Disabled = should_run {
            return;
        }

        let exe_file = self.make_exe_name();

        let debugger_run_result;
        // If bootstrap gave us an `--android-cross-path`, assume the target
        // needs Android-specific handling.
        if let Some(android_cross_path) = self.config.android_cross_path.as_deref() {
            cmds = cmds.replace("run", "continue");

            // write debugger script
            let mut script_str = String::with_capacity(2048);
            script_str.push_str(&format!("set charset {}\n", Self::charset()));
            script_str.push_str(&format!("set sysroot {android_cross_path}\n"));
            script_str.push_str(&format!("file {}\n", exe_file));
            script_str.push_str("target remote :5039\n");
            script_str.push_str(&format!(
                "set solib-search-path \
                 ./{}/stage2/lib/rustlib/{}/lib/\n",
                self.config.host, self.config.target
            ));
            for line in &dbg_cmds.breakpoint_lines {
                script_str.push_str(
                    format!("break {}:{}\n", self.testpaths.file.file_name().unwrap(), *line)
                        .as_str(),
                );
            }
            script_str.push_str(&cmds);
            script_str.push_str("\nquit\n");

            debug!("script_str = {}", script_str);
            self.dump_output_file(&script_str, "debugger.script");

            // Note: when `--android-cross-path` is specified, we expect both `adb_path` and
            // `adb_test_dir` to be available.
            let adb_path = self.config.adb_path.as_ref().expect("`adb_path` must be specified");
            let adb_test_dir =
                self.config.adb_test_dir.as_ref().expect("`adb_test_dir` must be specified");

            Command::new(adb_path)
                .arg("push")
                .arg(&exe_file)
                .arg(adb_test_dir)
                .status()
                .unwrap_or_else(|e| panic!("failed to exec `{adb_path:?}`: {e:?}"));

            Command::new(adb_path)
                .args(&["forward", "tcp:5039", "tcp:5039"])
                .status()
                .unwrap_or_else(|e| panic!("failed to exec `{adb_path:?}`: {e:?}"));

            let adb_arg = format!(
                "export LD_LIBRARY_PATH={}; \
                 gdbserver{} :5039 {}/{}",
                adb_test_dir,
                if self.config.target.contains("aarch64") { "64" } else { "" },
                adb_test_dir,
                exe_file.file_name().unwrap()
            );

            debug!("adb arg: {}", adb_arg);
            let mut adb = Command::new(adb_path)
                .args(&["shell", &adb_arg])
                .stdout(Stdio::piped())
                .stderr(Stdio::inherit())
                .spawn()
                .unwrap_or_else(|e| panic!("failed to exec `{adb_path:?}`: {e:?}"));

            // Wait for the gdbserver to print out "Listening on port ..."
            // at which point we know that it's started and then we can
            // execute the debugger below.
            let mut stdout = BufReader::new(adb.stdout.take().unwrap());
            let mut line = String::new();
            loop {
                line.clear();
                stdout.read_line(&mut line).unwrap();
                if line.starts_with("Listening on port 5039") {
                    break;
                }
            }
            drop(stdout);

            let mut debugger_script = OsString::from("-command=");
            debugger_script.push(self.make_out_name("debugger.script"));
            let debugger_opts: &[&OsStr] =
                &["-quiet".as_ref(), "-batch".as_ref(), "-nx".as_ref(), &debugger_script];

            let gdb_path = self.config.gdb.as_ref().unwrap();
            let Output { status, stdout, stderr } = Command::new(&gdb_path)
                .args(debugger_opts)
                .output()
                .unwrap_or_else(|e| panic!("failed to exec `{gdb_path:?}`: {e:?}"));
            let cmdline = {
                let mut gdb = Command::new(&format!("{}-gdb", self.config.target));
                gdb.args(debugger_opts);
                // FIXME(jieyouxu): don't pass an empty Path
                let cmdline = self.make_cmdline(&gdb, Utf8Path::new(""));
                self.logv(format_args!("executing {cmdline}"));
                cmdline
            };

            debugger_run_result = ProcRes {
                status,
                stdout: String::from_utf8(stdout).unwrap(),
                stderr: String::from_utf8(stderr).unwrap(),
                truncated: Truncated::No,
                cmdline,
            };
            if adb.kill().is_err() {
                writeln!(self.stdout, "Adb process is already finished.");
            }
        } else {
            let rust_pp_module_abs_path = self.config.src_root.join("src").join("etc");
            // write debugger script
            let mut script_str = String::with_capacity(2048);
            script_str.push_str(&format!("set charset {}\n", Self::charset()));
            script_str.push_str("show version\n");

            match self.config.gdb_version {
                Some(version) => {
                    writeln!(
                        self.stdout,
                        "NOTE: compiletest thinks it is using GDB version {}",
                        version
                    );

                    if !self.props.disable_gdb_pretty_printers
                        && version > extract_gdb_version("7.4").unwrap()
                    {
                        // Add the directory containing the pretty printers to
                        // GDB's script auto loading safe path
                        script_str.push_str(&format!(
                            "add-auto-load-safe-path {}\n",
                            rust_pp_module_abs_path.as_str().replace(r"\", r"\\")
                        ));

                        // Add the directory containing the output binary to
                        // include embedded pretty printers to GDB's script
                        // auto loading safe path
                        script_str.push_str(&format!(
                            "add-auto-load-safe-path {}\n",
                            self.output_base_dir().as_str().replace(r"\", r"\\")
                        ));

                        // GDB visualizer scripts aren't properly embedded on `*-windows-gnu`
                        // at the moment (see: issue #156687), so we need to load them in
                        // manually.
                        #[cfg(target_os = "windows")]
                        {
                            script_str.push_str(&format!(
                                "source {}\n",
                                self.config
                                    .src_root
                                    .join("src/etc/gdb_load_rust_pretty_printers.py")
                            ));
                        }
                    }
                }
                _ => {
                    writeln!(
                        self.stdout,
                        "NOTE: compiletest does not know which version of \
                         GDB it is using"
                    );
                }
            }

            // The following line actually doesn't have to do anything with
            // pretty printing, it just tells GDB to print values on one line:
            script_str.push_str("set print pretty off\n");

            // Add the pretty printer directory to GDB's source-file search path
            script_str.push_str(&format!(
                "directory {}\n",
                rust_pp_module_abs_path.as_str().replace(r"\", r"\\")
            ));

            // Load the target executable
            script_str.push_str(&format!("file {}\n", exe_file.as_str().replace(r"\", r"\\")));

            // Force GDB to print values in the Rust format.
            script_str.push_str("set language rust\n");

            // Add line breakpoints
            for line in &dbg_cmds.breakpoint_lines {
                script_str.push_str(&format!(
                    "break '{}':{}\n",
                    self.testpaths.file.file_name().unwrap(),
                    *line
                ));
            }

            script_str.push_str(&cmds);
            script_str.push_str("\nquit\n");

            debug!("script_str = {}", script_str);
            self.dump_output_file(&script_str, "debugger.script");

            let mut debugger_script = OsString::from("-command=");
            debugger_script.push(self.make_out_name("debugger.script"));

            let debugger_opts: &[&OsStr] =
                &["-quiet".as_ref(), "-batch".as_ref(), "-nx".as_ref(), &debugger_script];

            let mut gdb = Command::new(self.config.gdb.as_ref().unwrap());

            let pythonpath = with_pythonpath_prepended(&rust_pp_module_abs_path);
            gdb.args(debugger_opts).env("PYTHONPATH", pythonpath);

            debugger_run_result =
                self.compose_and_run(gdb, self.config.target_run_lib_path.as_path(), None, None);
        }

        if !debugger_run_result.status.success() {
            self.fatal_proc_rec("gdb failed to execute", &debugger_run_result);
        }

        if let Err(e) = dbg_cmds.check_output(&debugger_run_result) {
            self.fatal_proc_rec(&e, &debugger_run_result);
        }
    }

    fn run_debuginfo_lldb_test(&self) {
        let Some(ref lldb) = self.config.lldb else {
            self.fatal("Can't run LLDB test because LLDB's path is not set.");
        };

        // compile test file (it should have 'compile-flags:-g' in the directive)
        let should_run = self.run_if_enabled();
        let compile_result = self.compile_test(should_run, Emit::None);
        if !compile_result.status.success() {
            self.fatal_proc_rec("compilation failed!", &compile_result);
        }
        if let WillExecute::Disabled = should_run {
            return;
        }

        let exe_file = self.make_exe_name();

        match self.config.lldb_version {
            Some(ref version) => {
                writeln!(
                    self.stdout,
                    "NOTE: compiletest thinks it is using LLDB version {}",
                    version
                );
            }
            _ => {
                writeln!(
                    self.stdout,
                    "NOTE: compiletest does not know which version of \
                     LLDB it is using"
                );
            }
        }

        // Parse debugger commands etc from test files
        let dbg_cmds = DebuggerCommands::parse_from(&self.testpaths.file, "lldb", self.revision)
            .unwrap_or_else(|e| self.fatal(&e));

        // Write debugger script:
        // We don't want to hang when calling `quit` while the process is still running
        let mut script_str = String::from("settings set auto-confirm true\n");

        // macOS has a system for restricting access to files and peripherals
        // called Transparency, Consent, and Control (TCC), which can be
        // configured using the "Security & Privacy" tab in your settings.
        //
        // This system is provenance-based: if Terminal.app is given access to
        // your Desktop, and you launch a binary within Terminal.app, the new
        // binary also has access to the files on your Desktop.
        //
        // By default though, LLDB launches binaries in very isolated
        // contexts. This includes resetting any TCC grants that might
        // otherwise have been inherited.
        //
        // In effect, this means that if the developer has placed the rust
        // repository under one of the system-protected folders, they will get
        // a pop-up _for each binary_ asking for permissions to access the
        // folder - quite annoying.
        //
        // To avoid this, we tell LLDB to spawn processes with TCC grants
        // inherited from the parent process.
        //
        // Setting this also avoids unnecessary overhead from XprotectService
        // when running with the Developer Tool grant.
        //
        // TIP: If you want to allow launching `lldb ~/Desktop/my_binary`
        // without being prompted, you can put this in your `~/.lldbinit` too.
        if self.config.host.contains("darwin") {
            script_str.push_str("settings set target.inherit-tcc true\n");
        }

        // Make LLDB emit its version, so we have it documented in the test output
        script_str.push_str("version\n");

        // Switch LLDB into "Rust mode".
        let rust_pp_module_abs_path = self.config.src_root.join("src/etc");

        script_str.push_str(&format!(
            "command script import {}/lldb_lookup.py\n",
            rust_pp_module_abs_path
        ));
        script_str.push_str("script print(lldb_lookup.FEATURE_FLAGS)\n");

        // Set breakpoints on every line that contains the string "#break"
        let source_file_name = self.testpaths.file.file_name().unwrap();
        for line in &dbg_cmds.breakpoint_lines {
            script_str.push_str(&format!(
                "breakpoint set --file '{}' --line {}\n",
                source_file_name, line
            ));
        }

        // Append the other commands
        for line in &dbg_cmds.commands {
            script_str.push_str(line);
            script_str.push('\n');
        }

        // Finally, quit the debugger
        script_str.push_str("\nquit\n");

        // Write the script into a file
        debug!("script_str = {}", script_str);
        self.dump_output_file(&script_str, "debugger.script");
        let debugger_script = self.make_out_name("debugger.script");

        // Let LLDB execute the script via lldb_batchmode.py
        let debugger_run_result = self.run_lldb(lldb, &exe_file, &debugger_script);

        if !debugger_run_result.status.success() {
            self.fatal_proc_rec("Error while running LLDB", &debugger_run_result);
        }

        if let Err(e) = dbg_cmds.check_output(&debugger_run_result) {
            self.fatal_proc_rec(&e, &debugger_run_result);
        }
    }

    fn run_lldb(
        &self,
        lldb: &Utf8Path,
        test_executable: &Utf8Path,
        debugger_script: &Utf8Path,
    ) -> ProcRes {
        // Path containing `lldb_batchmode.py`, so that the `script` command can import it.
        let rust_pp_module_abs_path = self.config.src_root.join("src/etc");
        let pythonpath = with_pythonpath_prepended(&rust_pp_module_abs_path);
        // make sure `PATH` points to all the dlls necessary to run the debugee
        let path = prepend_to_path(&self.config.target_run_lib_path);

        let mut cmd = Command::new(lldb);
        cmd.arg("--one-line")
            .arg("script --language python -- import lldb_batchmode; lldb_batchmode.main()")
            .env("LLDB_BATCHMODE_TARGET_PATH", test_executable)
            .env("LLDB_BATCHMODE_SCRIPT_PATH", debugger_script)
            .env("PYTHONUNBUFFERED", "1") // Help debugging #78665
            .env("PYTHONPATH", pythonpath)
            .env("PATH", path);

        self.run_command_to_procres(&mut cmd)
    }
}

fn with_pythonpath_prepended(some_path: &Utf8Path) -> String {
    // FIXME: we are propagating `PYTHONPATH` from the environment, not a compiletest flag!
    if let Ok(pp) = std::env::var("PYTHONPATH") {
        #[cfg(target_os = "windows")]
        {
            format!("{pp};{some_path}")
        }
        #[cfg(not(target_os = "windows"))]
        {
            format!("{pp}:{some_path}")
        }
    } else {
        some_path.to_string()
    }
}

fn prepend_to_path(some_path: &Utf8Path) -> String {
    if let Ok(path) = std::env::var("PATH") {
        #[cfg(target_os = "windows")]
        {
            format!("{some_path};{path}")
        }
        #[cfg(not(target_os = "windows"))]
        {
            format!("{some_path}:{path}")
        }
    } else {
        some_path.to_string()
    }
}