Add gdb to the build

.gitmodules

@@ -52,6 +52,10 @@
 	path = src/tools/clang
 	url = https://github.com/rust-lang-nursery/clang.git
 	branch = rust-release-80-v2
+[submodule "src/tools/gdb"]
+	path = src/tools/gdb
+	url = https://github.com/rust-dev-tools/gdb.git
+	branch = rust-8.2
 [submodule "src/doc/rustc-guide"]
 	path = src/doc/rustc-guide
 	url = https://github.com/rust-lang/rustc-guide.git

config.toml.example

@@ -383,6 +383,9 @@
 # This is only built if LLVM is also being built.
 #lldb = false
 
+# Indicates whether GDB will also be built.
+#build-gdb = false
+
 # Whether to deny warnings in crates
 #deny-warnings = true
 

src/bootstrap/bootstrap.py

@@ -723,6 +723,10 @@ def update_submodules(self):
                 config = self.get_toml('lldb')
                 if config is None or config == 'false':
                     continue
+            if module.endswith("gdb"):
+                config = self.get_toml('build-gdb')
+                if config is None or config == 'false':
+                    continue
             check = self.check_submodule(module, slow_submodules)
             filtered_submodules.append((module, check))
             submodules_names.append(module)

src/bootstrap/builder.rs

@@ -363,6 +363,7 @@ impl<'a> Builder<'a> {
                 tool::Rustdoc,
                 tool::Clippy,
                 native::Llvm,
+                native::Gdb,
                 tool::Rustfmt,
                 tool::Miri,
                 native::Lld
@@ -461,6 +462,7 @@ impl<'a> Builder<'a> {
                 dist::Clippy,
                 dist::LlvmTools,
                 dist::Lldb,
+                dist::Gdb,
                 dist::Extended,
                 dist::HashSign
             ),

src/bootstrap/config.rs

@@ -92,6 +92,8 @@ pub struct Config {
     pub lldb_enabled: bool,
     pub llvm_tools_enabled: bool,
 
+    pub gdb_enabled: bool,
+
     // rust codegen options
     pub rust_optimize: bool,
     pub rust_codegen_units: Option<u32>,
@@ -320,6 +322,7 @@ struct Rust {
     wasm_syscall: Option<bool>,
     lld: Option<bool>,
     lldb: Option<bool>,
+    build_gdb: Option<bool>,
     llvm_tools: Option<bool>,
     deny_warnings: Option<bool>,
     backtrace_on_ice: Option<bool>,
@@ -552,6 +555,7 @@ impl Config {
             set(&mut config.wasm_syscall, rust.wasm_syscall);
             set(&mut config.lld_enabled, rust.lld);
             set(&mut config.lldb_enabled, rust.lldb);
+            set(&mut config.gdb_enabled, rust.build_gdb);
             set(&mut config.llvm_tools_enabled, rust.llvm_tools);
             config.rustc_parallel_queries = rust.experimental_parallel_queries.unwrap_or(false);
             config.rustc_default_linker = rust.default_linker.clone();

src/bootstrap/configure.py

@@ -70,6 +70,7 @@ def v(*args):
 o("full-tools", None, "enable all tools")
 o("lld", "rust.lld", "build lld")
 o("lldb", "rust.lldb", "build lldb")
+o("gdb", "rust.build-gdb", "build gdb")
 o("missing-tools", "dist.missing-tools", "allow failures when building tools")
 
 # Optimization and debugging options. These may be overridden by the release

src/bootstrap/dist.rs

@@ -35,6 +35,11 @@ use crate::tool::{self, Tool};
 use crate::cache::{INTERNER, Interned};
 use time;
 
+#[cfg(unix)]
+use std::os::unix::fs::symlink as symlink_file;
+#[cfg(windows)]
+use std::os::windows::fs::symlink_file;
+
 pub fn pkgname(builder: &Builder, component: &str) -> String {
     if component == "cargo" {
         format!("{}-{}", component, builder.cargo_package_vers())
@@ -48,6 +53,8 @@ pub fn pkgname(builder: &Builder, component: &str) -> String {
         format!("{}-{}", component, builder.llvm_tools_package_vers())
     } else if component == "lldb" {
         format!("{}-{}", component, builder.lldb_package_vers())
+    } else if component == "gdb" {
+        format!("{}-{}", component, builder.gdb_package_vers())
     } else {
         assert!(component.starts_with("rust"));
         format!("{}-{}", component, builder.rust_package_vers())
@@ -1400,6 +1407,7 @@ impl Step for Extended {
         let llvm_tools_installer = builder.ensure(LlvmTools { stage, target });
         let clippy_installer = builder.ensure(Clippy { stage, target });
         let lldb_installer = builder.ensure(Lldb { target });
+        let gdb_installer = builder.ensure(Gdb { target });
         let mingw_installer = builder.ensure(Mingw { host: target });
         let analysis_installer = builder.ensure(Analysis {
             compiler: builder.compiler(stage, self.host),
@@ -1440,6 +1448,7 @@ impl Step for Extended {
         tarballs.extend(rustfmt_installer.clone());
         tarballs.extend(llvm_tools_installer);
         tarballs.extend(lldb_installer);
+        tarballs.extend(gdb_installer);
         tarballs.push(analysis_installer);
         tarballs.push(std_installer);
         if builder.config.docs {
@@ -1873,6 +1882,7 @@ impl Step for HashSign {
         cmd.arg(builder.package_vers(&builder.release_num("rustfmt")));
         cmd.arg(builder.llvm_tools_package_vers());
         cmd.arg(builder.lldb_package_vers());
+        cmd.arg(builder.gdb_package_vers());
         cmd.arg(addr);
 
         builder.create_dir(&distdir(builder));
@@ -2121,3 +2131,92 @@ impl Step for Lldb {
         Some(distdir(builder).join(format!("{}-{}.tar.gz", name, target)))
     }
 }
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub struct Gdb {
+    pub target: Interned<String>,
+}
+
+impl Step for Gdb {
+    type Output = Option<PathBuf>;
+    const DEFAULT: bool = true;
+    const ONLY_HOSTS: bool = false;
+
+    fn should_run(run: ShouldRun) -> ShouldRun {
+        let builder = run.builder;
+        run.path("src/tools/gdb").default_condition(builder.config.gdb_enabled)
+    }
+
+    fn make_run(run: RunConfig) {
+        run.builder.ensure(Gdb {
+            target: run.target,
+        });
+    }
+
+    fn run(self, builder: &Builder) -> Option<PathBuf> {
+        let target = self.target;
+
+        if builder.config.dry_run {
+            return None;
+        }
+
+        let gdb_install = builder.gdb_out(target).join("install");
+        let bindir = gdb_install.join("bin");
+        let gdb_exe = bindir.join(exe("gdb", &target));
+        if !gdb_exe.exists() {
+            return None;
+        }
+
+        builder.info(&format!("Dist Gdb ({})", target));
+        let src = builder.src.join("src/tools/gdb");
+        let name = pkgname(builder, "gdb");
+
+        let tmp = tmpdir(builder);
+        let image = tmp.join("gdb-image");
+        drop(fs::remove_dir_all(&image));
+
+        // Prepare the image directory
+        let root = image.join("lib/rustlib").join(&*target);
+        let dst = root.join("bin");
+        t!(fs::create_dir_all(&dst));
+        // Install gdb as real-gdb, and run-gdb as gdb.
+        let filename = bindir.join(exe("gdb", &target));
+        builder.copy(&filename, &dst.join(exe("real-gdb", &target)));
+        let filename = bindir.join(exe("run-gdb", &target));
+        builder.copy(&filename, &dst.join(exe("gdb", &target)));
+
+        // gdb "share" files.
+        let sharedir = gdb_install.join("share/gdb");
+        let dst = root.join("share/gdb");
+        t!(fs::create_dir_all(&dst));
+        builder.cp_r(&sharedir, &dst);
+
+        // We want to pick up the system auto-loads.
+        t!(symlink_file(&Path::new("/usr/share/gdb/auto-load"), &dst.join("auto-load")));
+
+        // Prepare the overlay
+        let overlay = tmp.join("gdb-overlay");
+        drop(fs::remove_dir_all(&overlay));
+        builder.create_dir(&overlay);
+        builder.install(&src.join("COPYING3"), &overlay, 0o644);
+        builder.create(&overlay.join("version"), &builder.gdb_vers());
+
+        // Generate the installer tarball
+        let mut cmd = rust_installer(builder);
+        cmd.arg("generate")
+            .arg("--product-name=Rust")
+            .arg("--rel-manifest-dir=rustlib")
+            .arg("--success-message=gdb-installed.")
+            .arg("--image-dir").arg(&image)
+            .arg("--work-dir").arg(&tmpdir(builder))
+            .arg("--output-dir").arg(&distdir(builder))
+            .arg("--non-installed-overlay").arg(&overlay)
+            .arg(format!("--package-name={}-{}", name, target))
+            .arg("--legacy-manifest-dirs=rustlib,cargo")
+            .arg("--component-name=gdb");
+
+
+        builder.run(&mut cmd);
+        Some(distdir(builder).join(format!("{}-{}.tar.gz", name, target)))
+    }
+}

src/bootstrap/lib.rs

@@ -594,6 +594,11 @@ impl Build {
         self.out.join(&*target).join("lld")
     }
 
+    /// Output directory for gdb build.
+    fn gdb_out(&self, target: Interned<String>) -> PathBuf {
+        self.out.join(&*target).join("gdb")
+    }
+
     /// Output directory for all documentation for a target
     fn doc_out(&self, target: Interned<String>) -> PathBuf {
         self.out.join(&*target).join("doc")
@@ -1047,6 +1052,14 @@ impl Build {
         self.rust_version()
     }
 
+    fn gdb_package_vers(&self) -> String {
+        self.package_vers(&self.rust_version())
+    }
+
+    fn gdb_vers(&self) -> String {
+        self.rust_version()
+    }
+
     fn llvm_link_tools_dynamically(&self, target: Interned<String>) -> bool {
         (target.contains("linux-gnu") || target.contains("apple-darwin"))
     }

src/bootstrap/native.rs

@@ -473,6 +473,48 @@ impl Step for Lld {
     }
 }
 
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub struct Gdb {
+    pub target: Interned<String>,
+}
+
+impl Step for Gdb {
+    type Output = ();
+    const DEFAULT: bool = true;
+    const ONLY_HOSTS: bool = false;
+
+    fn should_run(run: ShouldRun) -> ShouldRun {
+        let builder = run.builder;
+        run.path("src/tools/gdb").default_condition(builder.config.gdb_enabled)
+    }
+
+    fn make_run(run: RunConfig) {
+        run.builder.ensure(Gdb {
+            target: run.target
+        });
+    }
+
+    fn run(self, builder: &Builder) {
+        if builder.config.dry_run {
+            return;
+        }
+
+        let root = builder.gdb_out(self.target);
+        let build = root.join("build");
+        let install = root.join("install");
+        let src = builder.src.join("src/tools/gdb");
+        t!(fs::create_dir_all(&build));
+        t!(fs::create_dir_all(&install));
+
+        let mut cmd = Command::new(&src.join("build-for-rust.sh"));
+        cmd.arg(&src)
+            .arg(&build)
+            .arg(&install);
+
+        builder.run(&mut cmd);
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub struct TestHelpers {
     pub target: Interned<String>,

src/bootstrap/sanity.rs

@@ -126,8 +126,7 @@ pub fn check(build: &mut Build) {
         .or_else(|| cmd_finder.maybe_have("node"))
         .or_else(|| cmd_finder.maybe_have("nodejs"));
 
-    build.config.gdb = build.config.gdb.take().map(|p| cmd_finder.must_have(p))
-        .or_else(|| cmd_finder.maybe_have("gdb"));
+    build.config.gdb = build.config.gdb.take().map(|p| cmd_finder.must_have(p));
 
     // We're gonna build some custom C code here and there, host triples
     // also build some C++ shims for LLVM so we need a C++ compiler.

src/bootstrap/test.rs

@@ -1111,8 +1111,14 @@ impl Step for Compiletest {
             cmd.arg("--lldb-python").arg(builder.python());
         }
 
+        // If config.toml specifies a gdb, use it; otherwise, if we
+        // built a gdb, prefer that.
         if let Some(ref gdb) = builder.config.gdb {
             cmd.arg("--gdb").arg(gdb);
+        } else if builder.config.gdb_enabled {
+            cmd.arg("--gdb").arg(builder.gdb_out(target).join("install/bin/gdb"));
+        } else {
+            cmd.arg("--gdb").arg("gdb");
         }
 
         let run = |cmd: &mut Command| {

src/ci/docker/dist-i686-linux/Dockerfile

@@ -23,7 +23,13 @@ RUN yum upgrade -y && yum install -y \
       pkgconfig \
       wget \
       autoconf \
-      gettext
+      gettext \
+      xz-static \
+      xz-devel \
+      expat-static \
+      expat-devel \
+      ncurses-static \
+      ncurses-devel
 
 ENV PATH=/rustroot/bin:$PATH
 ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib
@@ -95,6 +101,7 @@ ENV HOSTS=i686-unknown-linux-gnu
 
 ENV RUST_CONFIGURE_ARGS \
       --enable-full-tools \
+      --enable-gdb \
       --enable-sanitizers \
       --enable-profiler \
       --set target.i686-unknown-linux-gnu.linker=clang \

src/ci/docker/dist-x86_64-linux/Dockerfile

@@ -23,7 +23,13 @@ RUN yum upgrade -y && yum install -y \
       pkgconfig \
       wget \
       autoconf \
-      gettext
+      gettext \
+      xz-static \
+      xz-devel \
+      expat-static \
+      expat-devel \
+      ncurses-static \
+      ncurses-devel
 
 ENV PATH=/rustroot/bin:$PATH
 ENV LD_LIBRARY_PATH=/rustroot/lib64:/rustroot/lib
@@ -95,6 +101,7 @@ ENV HOSTS=x86_64-unknown-linux-gnu
 
 ENV RUST_CONFIGURE_ARGS \
       --enable-full-tools \
+      --enable-gdb \
       --enable-sanitizers \
       --enable-profiler \
       --enable-compiler-docs \

src/etc/rust-gdb

@@ -16,10 +16,22 @@ set -e
 RUSTC_SYSROOT=`rustc --print=sysroot`
 GDB_PYTHON_MODULE_DIRECTORY="$RUSTC_SYSROOT/lib/rustlib/etc"
 
+if [ -z "$RUST_GDB" ]; then
+    # Find the host triple so we can find lldb in rustlib.
+    host=`rustc -vV | sed -n -e 's/^host: //p'`
+    RUST_GDB=gdb
+    if [ -f "$RUSTC_SYSROOT/lib/rustlib/$host/bin/gdb" ]; then
+        bin="$RUSTC_SYSROOT/lib/rustlib/$host/bin"
+        # Pass the path to real-gdb to the wrapper.  This avoids
+        # having to modify PATH here, which might possibly be
+        # confusing inside gdb.
+        RUST_GDB="$bin/gdb $bin/real-gdb"
+    fi
+fi
+
 # Run GDB with the additional arguments that load the pretty printers
 # Set the environment variable `RUST_GDB` to overwrite the call to a
 # different/specific command (defaults to `gdb`).
-RUST_GDB="${RUST_GDB:-gdb}"
 PYTHONPATH="$PYTHONPATH:$GDB_PYTHON_MODULE_DIRECTORY" exec ${RUST_GDB} \
   --directory="$GDB_PYTHON_MODULE_DIRECTORY" \
   -iex "add-auto-load-safe-path $GDB_PYTHON_MODULE_DIRECTORY" \