Skip to content

Commit aaaf296

Browse files
borsbors
committed
Auto merge of #9112 - alexcrichton:split-debuginfo, r=ehuss
Add split-debuginfo profile option This commit adds a new `split-debuginfo` option to Cargo compilation profiles which gets forwarded to the `-Csplit-debuginfo` codegen option in rustc. This commit also sets the default, only on macOS, to be `-Csplit-debuginfo=unpacked`. The purpose of this change is to leverage rust-lang/rust#79570 to avoid running `dsymutil` on incremental builds while also preserving a pleasant debugging experience by default. This should lead to much faster incremental build times on macOS since `dsymutil` isn't exactly the speediest tool in the world. This is technically a breaking change in Cargo because we're no longer by-default producing the `*.dSYM` folders on macOS. If those are still desired, however, authors can always run `dsymutil` themselves or otherwise configure `split-debuginfo = 'packed'` in their manifest/profile configuration.
2 parents 537dc09 + ffa9dbd commit aaaf296

File tree

19 files changed

+303
-216
lines changed

19 files changed

+303
-216
lines changed

‎crates/cargo-test-support/src/lib.rs

+56-70
Original file line numberDiff line numberDiff line change
@@ -722,6 +722,16 @@ impl Execs {
722722
self
723723
}
724724

725+
pub fn enable_mac_dsym(&mut self) -> &mut Self {
726+
if cfg!(target_os = "macos") {
727+
self.env("CARGO_PROFILE_DEV_SPLIT_DEBUGINFO", "packed")
728+
.env("CARGO_PROFILE_TEST_SPLIT_DEBUGINFO", "packed")
729+
.env("CARGO_PROFILE_RELEASE_SPLIT_DEBUGINFO", "packed")
730+
.env("CARGO_PROFILE_BENCH_SPLIT_DEBUGINFO", "packed");
731+
}
732+
self
733+
}
734+
725735
pub fn run(&mut self) {
726736
self.ran = true;
727737
let p = (&self.process_builder).clone().unwrap();
@@ -788,13 +798,17 @@ impl Execs {
788798
match res {
789799
Ok(out) => self.match_output(&out),
790800
Err(e) => {
791-
let err = e.downcast_ref::<ProcessError>();
792-
if let Some(&ProcessError {
793-
output: Some(ref out),
801+
if let Some(ProcessError {
802+
stdout: Some(stdout),
803+
stderr: Some(stderr),
804+
code,
794805
..
795-
}) = err
806+
}) = e.downcast_ref::<ProcessError>()
796807
{
797-
return self.match_output(out);
808+
return self
809+
.match_status(*code, stdout, stderr)
810+
.and(self.match_stdout(stdout, stderr))
811+
.and(self.match_stderr(stdout, stderr));
798812
}
799813
Err(format!("could not exec process {}: {:?}", process, e))
800814
}
@@ -803,119 +817,91 @@ impl Execs {
803817

804818
fn match_output(&self, actual: &Output) -> MatchResult {
805819
self.verify_checks_output(actual);
806-
self.match_status(actual)
807-
.and(self.match_stdout(actual))
808-
.and(self.match_stderr(actual))
820+
self.match_status(actual.status.code(), &actual.stdout, &actual.stderr)
821+
.and(self.match_stdout(&actual.stdout, &actual.stderr))
822+
.and(self.match_stderr(&actual.stdout, &actual.stderr))
809823
}
810824

811-
fn match_status(&self, actual: &Output) -> MatchResult {
825+
fn match_status(&self, code: Option<i32>, stdout: &[u8], stderr: &[u8]) -> MatchResult {
812826
match self.expect_exit_code {
813827
None => Ok(()),
814-
Some(code) if actual.status.code() == Some(code) => Ok(()),
828+
Some(expected) if code == Some(expected) => Ok(()),
815829
Some(_) => Err(format!(
816-
"exited with {}\n--- stdout\n{}\n--- stderr\n{}",
817-
actual.status,
818-
String::from_utf8_lossy(&actual.stdout),
819-
String::from_utf8_lossy(&actual.stderr)
830+
"exited with {:?}\n--- stdout\n{}\n--- stderr\n{}",
831+
code,
832+
String::from_utf8_lossy(&stdout),
833+
String::from_utf8_lossy(&stderr)
820834
)),
821835
}
822836
}
823837

824-
fn match_stdout(&self, actual: &Output) -> MatchResult {
838+
fn match_stdout(&self, stdout: &[u8], stderr: &[u8]) -> MatchResult {
825839
self.match_std(
826840
self.expect_stdout.as_ref(),
827-
&actual.stdout,
841+
stdout,
828842
"stdout",
829-
&actual.stderr,
843+
stderr,
830844
MatchKind::Exact,
831845
)?;
832846
for expect in self.expect_stdout_contains.iter() {
833-
self.match_std(
834-
Some(expect),
835-
&actual.stdout,
836-
"stdout",
837-
&actual.stderr,
838-
MatchKind::Partial,
839-
)?;
847+
self.match_std(Some(expect), stdout, "stdout", stderr, MatchKind::Partial)?;
840848
}
841849
for expect in self.expect_stderr_contains.iter() {
842-
self.match_std(
843-
Some(expect),
844-
&actual.stderr,
845-
"stderr",
846-
&actual.stdout,
847-
MatchKind::Partial,
848-
)?;
850+
self.match_std(Some(expect), stderr, "stderr", stdout, MatchKind::Partial)?;
849851
}
850852
for &(ref expect, number) in self.expect_stdout_contains_n.iter() {
851853
self.match_std(
852854
Some(expect),
853-
&actual.stdout,
855+
stdout,
854856
"stdout",
855-
&actual.stderr,
857+
stderr,
856858
MatchKind::PartialN(number),
857859
)?;
858860
}
859861
for expect in self.expect_stdout_not_contains.iter() {
860862
self.match_std(
861863
Some(expect),
862-
&actual.stdout,
864+
stdout,
863865
"stdout",
864-
&actual.stderr,
866+
stderr,
865867
MatchKind::NotPresent,
866868
)?;
867869
}
868870
for expect in self.expect_stderr_not_contains.iter() {
869871
self.match_std(
870872
Some(expect),
871-
&actual.stderr,
873+
stderr,
872874
"stderr",
873-
&actual.stdout,
875+
stdout,
874876
MatchKind::NotPresent,
875877
)?;
876878
}
877879
for expect in self.expect_stderr_unordered.iter() {
878-
self.match_std(
879-
Some(expect),
880-
&actual.stderr,
881-
"stderr",
882-
&actual.stdout,
883-
MatchKind::Unordered,
884-
)?;
880+
self.match_std(Some(expect), stderr, "stderr", stdout, MatchKind::Unordered)?;
885881
}
886882
for expect in self.expect_neither_contains.iter() {
887883
self.match_std(
888884
Some(expect),
889-
&actual.stdout,
885+
stdout,
890886
"stdout",
891-
&actual.stdout,
887+
stdout,
892888
MatchKind::NotPresent,
893889
)?;
894890

895891
self.match_std(
896892
Some(expect),
897-
&actual.stderr,
893+
stderr,
898894
"stderr",
899-
&actual.stderr,
895+
stderr,
900896
MatchKind::NotPresent,
901897
)?;
902898
}
903899

904900
for expect in self.expect_either_contains.iter() {
905-
let match_std = self.match_std(
906-
Some(expect),
907-
&actual.stdout,
908-
"stdout",
909-
&actual.stdout,
910-
MatchKind::Partial,
911-
);
912-
let match_err = self.match_std(
913-
Some(expect),
914-
&actual.stderr,
915-
"stderr",
916-
&actual.stderr,
917-
MatchKind::Partial,
918-
);
901+
let match_std =
902+
self.match_std(Some(expect), stdout, "stdout", stdout, MatchKind::Partial);
903+
let match_err =
904+
self.match_std(Some(expect), stderr, "stderr", stderr, MatchKind::Partial);
919905

920906
if let (Err(_), Err(_)) = (match_std, match_err) {
921907
return Err(format!(
@@ -928,12 +914,12 @@ impl Execs {
928914
}
929915

930916
for (with, without) in self.expect_stderr_with_without.iter() {
931-
self.match_with_without(&actual.stderr, with, without)?;
917+
self.match_with_without(stderr, with, without)?;
932918
}
933919

934920
if let Some(ref objects) = self.expect_json {
935-
let stdout = str::from_utf8(&actual.stdout)
936-
.map_err(|_| "stdout was not utf8 encoded".to_owned())?;
921+
let stdout =
922+
str::from_utf8(stdout).map_err(|_| "stdout was not utf8 encoded".to_owned())?;
937923
let lines = stdout
938924
.lines()
939925
.filter(|line| line.starts_with('{'))
@@ -952,8 +938,8 @@ impl Execs {
952938
}
953939

954940
if !self.expect_json_contains_unordered.is_empty() {
955-
let stdout = str::from_utf8(&actual.stdout)
956-
.map_err(|_| "stdout was not utf8 encoded".to_owned())?;
941+
let stdout =
942+
str::from_utf8(stdout).map_err(|_| "stdout was not utf8 encoded".to_owned())?;
957943
let mut lines = stdout
958944
.lines()
959945
.filter(|line| line.starts_with('{'))
@@ -980,12 +966,12 @@ impl Execs {
980966
Ok(())
981967
}
982968

983-
fn match_stderr(&self, actual: &Output) -> MatchResult {
969+
fn match_stderr(&self, stdout: &[u8], stderr: &[u8]) -> MatchResult {
984970
self.match_std(
985971
self.expect_stderr.as_ref(),
986-
&actual.stderr,
972+
stderr,
987973
"stderr",
988-
&actual.stdout,
974+
stdout,
989975
MatchKind::Exact,
990976
)
991977
}

‎src/bin/cargo/commands/bench.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,7 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
7474
let err = ops::run_benches(&ws, &ops, &bench_args)?;
7575
match err {
7676
None => Ok(()),
77-
Some(err) => Err(match err.exit.as_ref().and_then(|e| e.code()) {
77+
Some(err) => Err(match err.code {
7878
Some(i) => CliError::new(anyhow::format_err!("bench failed"), i),
7979
None => CliError::new(err.into(), 101),
8080
}),

‎src/bin/cargo/commands/run.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -90,15 +90,14 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
9090

9191
// If we never actually spawned the process then that sounds pretty
9292
// bad and we always want to forward that up.
93-
let exit = match proc_err.exit {
93+
let exit_code = match proc_err.code {
9494
Some(exit) => exit,
9595
None => return CliError::new(err, 101),
9696
};
9797

9898
// If `-q` was passed then we suppress extra error information about
9999
// a failed process, we assume the process itself printed out enough
100100
// information about why it failed so we don't do so as well
101-
let exit_code = exit.code().unwrap_or(101);
102101
let is_quiet = config.shell().verbosity() == Verbosity::Quiet;
103102
if is_quiet {
104103
CliError::code(exit_code)

‎src/bin/cargo/commands/test.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -125,7 +125,7 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
125125
None => Ok(()),
126126
Some(err) => {
127127
let context = anyhow::format_err!("{}", err.hint(&ws, &ops.compile_opts));
128-
let e = match err.exit.as_ref().and_then(|e| e.code()) {
128+
let e = match err.code {
129129
// Don't show "process didn't exit successfully" for simple errors.
130130
Some(i) if errors::is_simple_exit_code(i) => CliError::new(context, i),
131131
Some(i) => CliError::new(Error::from(err).context(context), i),

‎src/bin/cargo/main.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -171,7 +171,7 @@ fn execute_external_subcommand(config: &Config, cmd: &str, args: &[&str]) -> Cli
171171
};
172172

173173
if let Some(perr) = err.downcast_ref::<ProcessError>() {
174-
if let Some(code) = perr.exit.as_ref().and_then(|c| c.code()) {
174+
if let Some(code) = perr.code {
175175
return Err(CliError::code(code));
176176
}
177177
}

‎src/cargo/core/compiler/build_context/target_info.rs

+6
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,8 @@ pub struct TargetInfo {
4040
pub rustflags: Vec<String>,
4141
/// Extra flags to pass to `rustdoc`, see `env_args`.
4242
pub rustdocflags: Vec<String>,
43+
/// Whether or not rustc supports the `-Csplit-debuginfo` flag.
44+
pub supports_split_debuginfo: bool,
4345
}
4446

4547
/// Kind of each file generated by a Unit, part of `FileType`.
@@ -157,6 +159,9 @@ impl TargetInfo {
157159
for crate_type in KNOWN_CRATE_TYPES.iter() {
158160
process.arg("--crate-type").arg(crate_type.as_str());
159161
}
162+
let supports_split_debuginfo = rustc
163+
.cached_output(process.clone().arg("-Csplit-debuginfo=packed"))
164+
.is_ok();
160165

161166
process.arg("--print=sysroot");
162167
process.arg("--print=cfg");
@@ -231,6 +236,7 @@ impl TargetInfo {
231236
"RUSTDOCFLAGS",
232237
)?,
233238
cfg,
239+
supports_split_debuginfo,
234240
})
235241
}
236242

‎src/cargo/core/compiler/mod.rs

+11-1
Original file line numberDiff line numberDiff line change
@@ -297,7 +297,7 @@ fn rustc(cx: &mut Context<'_, '_>, unit: &Unit, exec: &Arc<dyn Executor>) -> Car
297297
match err
298298
.downcast_ref::<ProcessError>()
299299
.as_ref()
300-
.and_then(|perr| perr.exit.and_then(|e| e.code()))
300+
.and_then(|perr| perr.code)
301301
{
302302
Some(n) if errors::is_simple_exit_code(n) => VerboseError::new(err).into(),
303303
_ => err,
@@ -768,6 +768,7 @@ fn build_base_args(
768768
codegen_units,
769769
debuginfo,
770770
debug_assertions,
771+
split_debuginfo,
771772
overflow_checks,
772773
rpath,
773774
ref panic,
@@ -820,6 +821,15 @@ fn build_base_args(
820821

821822
cmd.args(&lto_args(cx, unit));
822823

824+
// This is generally just an optimization on build time so if we don't pass
825+
// it then it's ok. As of the time of this writing it's a very new flag, so
826+
// we need to dynamically check if it's available.
827+
if cx.bcx.target_data.info(unit.kind).supports_split_debuginfo {
828+
if let Some(split) = split_debuginfo {
829+
cmd.arg("-C").arg(format!("split-debuginfo={}", split));
830+
}
831+
}
832+
823833
if let Some(n) = codegen_units {
824834
cmd.arg("-C").arg(&format!("codegen-units={}", n));
825835
}

0 commit comments

Comments
 (0)