pub rust_profile_use: Option<String>,
pub rust_profile_generate: Option<String>,
+
+ pub llvm_profile_use: Option<String>,
+ // LLVM doesn't support a custom location for generating profile
+ // information.
+ //
+ // llvm_out/build/profiles/ is the location this writes to.
+ pub llvm_profile_generate: bool,
}
pub enum Subcommand {
paths: Vec<PathBuf>,
},
Check {
- // Whether to run checking over all targets (e.g., unit / integration
- // tests).
- all_targets: bool,
paths: Vec<PathBuf>,
},
Clippy {
VALUE overrides the skip-rebuild option in config.toml.",
"VALUE",
);
- opts.optopt("", "rust-profile-generate", "generate PGO profile with rustc build", "FORMAT");
- opts.optopt("", "rust-profile-use", "use PGO profile for rustc build", "FORMAT");
+ opts.optopt(
+ "",
+ "rust-profile-generate",
+ "generate PGO profile with rustc build",
+ "PROFILE",
+ );
+ opts.optopt("", "rust-profile-use", "use PGO profile for rustc build", "PROFILE");
+ opts.optflag("", "llvm-profile-generate", "generate PGO profile with llvm built for rustc");
+ opts.optopt("", "llvm-profile-use", "use PGO profile for llvm build", "PROFILE");
// We can't use getopt to parse the options until we have completed specifying which
// options are valid, but under the current implementation, some options are conditional on
"\n
Arguments:
This subcommand accepts a number of paths to directories to the crates
- and/or artifacts to compile. For example:
-
- ./x.py build library/core
- ./x.py build library/core library/proc_macro
- ./x.py build library/std --stage 1
+ and/or artifacts to compile. For example, for a quick build of a usable
+ compiler:
- If no arguments are passed then the complete artifacts for that stage are
- also compiled.
+ ./x.py build --stage 1 library/std
- ./x.py build
- ./x.py build --stage 1
+ This will build a compiler and standard library from the local source code.
+ Once this is done, build/$ARCH/stage1 contains a usable compiler.
- For a quick build of a usable compiler, you can pass:
+ If no arguments are passed then the default artifacts for that stage are
+ compiled. For example:
- ./x.py build --stage 1 library/test
-
- This will first build everything once (like `--stage 0` without further
- arguments would), and then use the compiler built in stage 0 to build
- library/test and its dependencies.
- Once this is done, build/$ARCH/stage1 contains a usable compiler.",
+ ./x.py build --stage 0
+ ./x.py build ",
);
}
"check" | "c" => {
This subcommand accepts a number of paths to directories to the crates
and/or artifacts to compile. For example:
- ./x.py check library/core
- ./x.py check library/core library/proc_macro
+ ./x.py check library/std
- If no arguments are passed then the complete artifacts are compiled: std, test, and rustc. Note
- also that since we use `cargo check`, by default this will automatically enable incremental
- compilation, so there's no need to pass it separately, though it won't hurt. We also completely
- ignore the stage passed, as there's no way to compile in non-stage 0 without actually building
- the compiler.",
+ If no arguments are passed then many artifacts are checked.",
);
}
"clippy" => {
let cmd = match subcommand.as_str() {
"build" | "b" => Subcommand::Build { paths },
"check" | "c" => {
- Subcommand::Check { paths, all_targets: matches.opt_present("all-targets") }
+ if matches.opt_present("all-targets") {
+ eprintln!(
+ "Warning: --all-targets is now on by default and does not need to be passed explicitly."
+ );
+ }
+ Subcommand::Check { paths }
}
"clippy" => Subcommand::Clippy { paths, fix: matches.opt_present("fix") },
"fix" => Subcommand::Fix { paths },
.expect("`color` should be `always`, `never`, or `auto`"),
rust_profile_use: matches.opt_str("rust-profile-use"),
rust_profile_generate: matches.opt_str("rust-profile-generate"),
+ llvm_profile_use: matches.opt_str("llvm-profile-use"),
+ llvm_profile_generate: matches.opt_present("llvm-profile-generate"),
}
}
}