debuginfo: Emit different autotest debugger scripts depending on GDB version.

Author: michaelwoerister

configure

@@ -509,6 +509,14 @@ probe CFG_LUALATEX         lualatex
 probe CFG_GDB              gdb
 probe CFG_LLDB             lldb
 
+if [ ! -z "$CFG_GDB" ]
+then
+    # Extract the version
+    CFG_GDB_VERSION=$($CFG_GDB --version 2>/dev/null | head -1 \
+                 |  sed -e 's/.*\([0-9]\+\.[0-9]\+$\)/\1/' )
+    putvar CFG_GDB_VERSION
+fi
+
 if [ ! -z "$CFG_LLDB" ]
 then
     # If CFG_LLDB_PYTHON_DIR is not already set from the outside and valid, try to read it from

mk/tests.mk

@@ -623,6 +623,7 @@ CTEST_COMMON_ARGS$(1)-T-$(2)-H-$(3) := \
         --stage-id stage$(1)-$(2) \
         --target $(2) \
         --host $(3) \
+        --gdb-version=$(CFG_GDB_VERSION) \
         --android-cross-path=$(CFG_ANDROID_CROSS_PATH) \
         --adb-path=$(CFG_ADB) \
         --adb-test-dir=$(CFG_ADB_TEST_DIR) \

src/compiletest/common.rs

@@ -130,6 +130,9 @@ pub struct Config {
     // Host triple for the compiler being invoked
     pub host: String,
 
+    // Version of GDB
+    pub gdb_version: Option<String>,
+
     // Path to the android tools
     pub android_cross_path: Path,
 

src/compiletest/compiletest.rs

@@ -81,6 +81,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
           optflag("", "jit", "run tests under the JIT"),
           optopt("", "target", "the target to build for", "TARGET"),
           optopt("", "host", "the host to build for", "HOST"),
+          optopt("", "gdb-version", "the version of GDB used", "MAJOR.MINOR"),
           optopt("", "android-cross-path", "Android NDK standalone path", "PATH"),
           optopt("", "adb-path", "path to the android debugger", "PATH"),
           optopt("", "adb-test-dir", "path to tests for the android debugger", "PATH"),
@@ -157,6 +158,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         jit: matches.opt_present("jit"),
         target: opt_str2(matches.opt_str("target")),
         host: opt_str2(matches.opt_str("host")),
+        gdb_version: matches.opt_str("gdb-version"),
         android_cross_path: opt_path(matches, "android-cross-path"),
         adb_path: opt_str2(matches.opt_str("adb-path")),
         adb_test_dir: opt_str2(matches.opt_str("adb-test-dir")),

src/compiletest/runtest.rs

@@ -20,6 +20,7 @@ use util::logv;
 #[cfg(stage0, target_os = "win32")] // NOTE: Remove after snapshot
 use util;
 
+use std::from_str::FromStr;
 use std::io::File;
 use std::io::fs;
 use std::io::net::tcp;
@@ -317,6 +318,7 @@ actual:\n\
 }
 
 fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
+
     let mut config = Config {
         target_rustcflags: cleanup_debug_info_options(&config.target_rustcflags),
         host_rustcflags: cleanup_debug_info_options(&config.host_rustcflags),
@@ -467,11 +469,38 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                                                        .unwrap()
                                                        .to_string();
             // write debugger script
-            let script_str = [
-                "set charset UTF-8".to_string(),
-                cmds,
-                "quit\n".to_string()
-            ].connect("\n");
+            let mut script_str = String::with_capacity(2048);
+
+            script_str.push_str("set charset UTF-8\n");
+            script_str.push_str("show version\n");
+
+            match config.gdb_version {
+                Some(ref version) => {
+                    if gdb_version_to_int(version.as_slice()) > gdb_version_to_int("7.3") {
+                        // 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_slice())
+                                .as_slice());
+                        // ... and also the test directory
+                        script_str.push_str(
+                            format!("add-auto-load-safe-path {}\n",
+                                    config.build_base.as_str().unwrap())
+                                .as_slice());
+                    }
+                }
+                _ => { /* nothing to do */ }
+            }
+
+            // Load the target executable
+            script_str.push_str(format!("file {}\n",
+                                        exe_file.as_str().unwrap())
+                                    .as_slice());
+
+            script_str.push_str(cmds.as_slice());
+            script_str.push_str("quit\n");
+
             debug!("script_str = {}", script_str);
             dump_output_file(config,
                              testfile,
@@ -501,15 +530,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
                 vec!("-quiet".to_string(),
                      "-batch".to_string(),
                      "-nx".to_string(),
-                     // Add the directory containing the pretty printers to
-                     // GDB's script auto loading safe path ...
-                     format!("-iex=add-auto-load-safe-path {}",
-                             rust_pp_module_abs_path.as_slice()),
-                     // ... and also the test directory
-                     format!("-iex=add-auto-load-safe-path {}",
-                             config.build_base.as_str().unwrap()),
-                     format!("-command={}", debugger_script.as_str().unwrap()),
-                     exe_file.as_str().unwrap().to_string());
+                     format!("-command={}", debugger_script.as_str().unwrap()));
 
             let proc_args = ProcArgs {
                 prog: debugger(),
@@ -546,6 +567,23 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
 
         File::create(&script_path).write(script_content).unwrap();
     }
+
+    fn gdb_version_to_int(version_string: &str) -> int {
+        let error_string = format!(
+            "Encountered GDB version string with unexpected format: {}",
+            version_string);
+
+        let components: Vec<&str> = version_string.trim().split('.').collect();
+
+        if components.len() != 2 {
+            fatal(error_string.as_slice());
+        }
+
+        let major: int = FromStr::from_str(components[0]).expect(error_string.as_slice());
+        let minor: int = FromStr::from_str(components[1]).expect(error_string.as_slice());
+
+        return major * 1000 + minor;
+    }
 }
 
 fn find_rust_src_root(config: &Config) -> Option<Path> {