1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! Contains infrastructure for configuring the compiler, including parsing
12 //! command line options.
14 pub use self::EntryFnType::*;
15 pub use self::CrateType::*;
16 pub use self::Passes::*;
17 pub use self::DebugInfoLevel::*;
19 use session::{early_error, early_warn, Session};
20 use session::search_paths::SearchPaths;
22 use rustc_back::{LinkerFlavor, PanicStrategy, RelroLevel};
23 use rustc_back::target::Target;
27 use syntax::ast::{self, IntTy, UintTy};
28 use syntax::codemap::FilePathMapping;
29 use syntax::parse::token;
31 use syntax::symbol::Symbol;
32 use syntax::feature_gate::UnstableFeatures;
34 use errors::{ColorConfig, FatalError, Handler};
37 use std::collections::{BTreeMap, BTreeSet};
38 use std::collections::btree_map::Iter as BTreeMapIter;
39 use std::collections::btree_map::Keys as BTreeMapKeysIter;
40 use std::collections::btree_map::Values as BTreeMapValuesIter;
43 use std::hash::Hasher;
44 use std::collections::hash_map::DefaultHasher;
45 use std::collections::HashSet;
46 use std::iter::FromIterator;
47 use std::path::PathBuf;
52 pub uint_type: UintTy,
55 #[derive(Clone, Hash, Debug)]
63 #[derive(Clone, Copy, PartialEq, Hash)]
73 #[derive(Clone, Copy, PartialEq, Hash)]
74 pub enum DebugInfoLevel {
80 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord,
81 RustcEncodable, RustcDecodable)]
94 fn is_compatible_with_codegen_units_and_single_output_file(&self) -> bool {
97 OutputType::DepInfo => true,
99 OutputType::Assembly |
100 OutputType::LlvmAssembly |
103 OutputType::Metadata => false,
107 fn shorthand(&self) -> &'static str {
109 OutputType::Bitcode => "llvm-bc",
110 OutputType::Assembly => "asm",
111 OutputType::LlvmAssembly => "llvm-ir",
112 OutputType::Mir => "mir",
113 OutputType::Object => "obj",
114 OutputType::Metadata => "metadata",
115 OutputType::Exe => "link",
116 OutputType::DepInfo => "dep-info",
120 pub fn extension(&self) -> &'static str {
122 OutputType::Bitcode => "bc",
123 OutputType::Assembly => "s",
124 OutputType::LlvmAssembly => "ll",
125 OutputType::Mir => "mir",
126 OutputType::Object => "o",
127 OutputType::Metadata => "rmeta",
128 OutputType::DepInfo => "d",
129 OutputType::Exe => "",
134 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
135 pub enum ErrorOutputType {
136 HumanReadable(ColorConfig),
140 impl Default for ErrorOutputType {
141 fn default() -> ErrorOutputType {
142 ErrorOutputType::HumanReadable(ColorConfig::Auto)
146 // Use tree-based collections to cheaply get a deterministic Hash implementation.
147 // DO NOT switch BTreeMap out for an unsorted container type! That would break
148 // dependency tracking for commandline arguments.
149 #[derive(Clone, Hash)]
150 pub struct OutputTypes(BTreeMap<OutputType, Option<PathBuf>>);
153 pub fn new(entries: &[(OutputType, Option<PathBuf>)]) -> OutputTypes {
154 OutputTypes(BTreeMap::from_iter(entries.iter()
155 .map(|&(k, ref v)| (k, v.clone()))))
158 pub fn get(&self, key: &OutputType) -> Option<&Option<PathBuf>> {
162 pub fn contains_key(&self, key: &OutputType) -> bool {
163 self.0.contains_key(key)
166 pub fn keys<'a>(&'a self) -> BTreeMapKeysIter<'a, OutputType, Option<PathBuf>> {
170 pub fn values<'a>(&'a self) -> BTreeMapValuesIter<'a, OutputType, Option<PathBuf>> {
174 // True if any of the output types require codegen or linking.
175 pub fn should_trans(&self) -> bool {
176 self.0.keys().any(|k| match *k {
177 OutputType::Bitcode |
178 OutputType::Assembly |
179 OutputType::LlvmAssembly |
182 OutputType::Exe => true,
183 OutputType::Metadata |
184 OutputType::DepInfo => false,
190 // Use tree-based collections to cheaply get a deterministic Hash implementation.
191 // DO NOT switch BTreeMap or BTreeSet out for an unsorted container type! That
192 // would break dependency tracking for commandline arguments.
193 #[derive(Clone, Hash)]
194 pub struct Externs(BTreeMap<String, BTreeSet<String>>);
197 pub fn new(data: BTreeMap<String, BTreeSet<String>>) -> Externs {
201 pub fn get(&self, key: &str) -> Option<&BTreeSet<String>> {
205 pub fn iter<'a>(&'a self) -> BTreeMapIter<'a, String, BTreeSet<String>> {
210 macro_rules! hash_option {
211 ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, [UNTRACKED]) => ({});
212 ($opt_name:ident, $opt_expr:expr, $sub_hashes:expr, [TRACKED]) => ({
213 if $sub_hashes.insert(stringify!($opt_name),
214 $opt_expr as &dep_tracking::DepTrackingHash).is_some() {
215 bug!("Duplicate key in CLI DepTrackingHash: {}", stringify!($opt_name))
221 [UNTRACKED_WITH_WARNING $warn_val:expr, $warn_text:expr, $error_format:expr]) => ({
222 if *$opt_expr == $warn_val {
223 early_warn($error_format, $warn_text)
228 macro_rules! top_level_options {
229 (pub struct Options { $(
230 $opt:ident : $t:ty [$dep_tracking_marker:ident $($warn_val:expr, $warn_text:expr)*],
238 pub fn dep_tracking_hash(&self) -> u64 {
239 let mut sub_hashes = BTreeMap::new();
244 [$dep_tracking_marker $($warn_val,
246 self.error_format)*]);
248 let mut hasher = DefaultHasher::new();
249 dep_tracking::stable_hash(sub_hashes,
258 // The top-level commandline options struct
260 // For each option, one has to specify how it behaves with regard to the
261 // dependency tracking system of incremental compilation. This is done via the
262 // square-bracketed directive after the field type. The options are:
265 // A change in the given field will cause the compiler to completely clear the
266 // incremental compilation cache before proceeding.
269 // Incremental compilation is not influenced by this option.
271 // [UNTRACKED_WITH_WARNING(val, warning)]
272 // The option is incompatible with incremental compilation in some way. If it
273 // has the value `val`, the string `warning` is emitted as a warning.
275 // If you add a new option to this struct or one of the sub-structs like
276 // CodegenOptions, think about how it influences incremental compilation. If in
277 // doubt, specify [TRACKED], which is always "correct" but might lead to
278 // unnecessary re-compilation.
281 // The crate config requested for the session, which may be combined
282 // with additional crate configurations during the compile process
283 crate_types: Vec<CrateType> [TRACKED],
284 optimize: OptLevel [TRACKED],
285 // Include the debug_assertions flag into dependency tracking, since it
286 // can influence whether overflow checks are done or not.
287 debug_assertions: bool [TRACKED],
288 debuginfo: DebugInfoLevel [TRACKED],
289 lint_opts: Vec<(String, lint::Level)> [TRACKED],
290 lint_cap: Option<lint::Level> [TRACKED],
291 describe_lints: bool [UNTRACKED],
292 output_types: OutputTypes [TRACKED],
293 // FIXME(mw): We track this for now but it actually doesn't make too
294 // much sense: The search path can stay the same while the
295 // things discovered there might have changed on disk.
296 search_paths: SearchPaths [TRACKED],
297 libs: Vec<(String, Option<String>, Option<cstore::NativeLibraryKind>)> [TRACKED],
298 maybe_sysroot: Option<PathBuf> [TRACKED],
300 target_triple: String [TRACKED],
302 test: bool [TRACKED],
303 error_format: ErrorOutputType [UNTRACKED],
305 // if Some, enable incremental compilation, using the given
306 // directory to store intermediate results
307 incremental: Option<PathBuf> [UNTRACKED],
309 debugging_opts: DebuggingOptions [TRACKED],
310 prints: Vec<PrintRequest> [UNTRACKED],
311 cg: CodegenOptions [TRACKED],
312 // FIXME(mw): We track this for now but it actually doesn't make too
313 // much sense: The value of this option can stay the same
314 // while the files they refer to might have changed on disk.
315 externs: Externs [TRACKED],
316 crate_name: Option<String> [TRACKED],
317 // An optional name to use as the crate for std during std injection,
318 // written `extern crate std = "name"`. Default to "std". Used by
319 // out-of-tree drivers.
320 alt_std_name: Option<String> [TRACKED],
321 // Indicates how the compiler should treat unstable features
322 unstable_features: UnstableFeatures [TRACKED],
324 // Indicates whether this run of the compiler is actually rustdoc. This
325 // is currently just a hack and will be removed eventually, so please
326 // try to not rely on this too much.
327 actually_rustdoc: bool [TRACKED],
331 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
332 pub enum PrintRequest {
347 /// Load source from file
350 /// String that is shown in place of a filename
352 /// Anonymous source string
358 pub fn filestem(&self) -> String {
360 Input::File(ref ifile) => ifile.file_stem().unwrap()
361 .to_str().unwrap().to_string(),
362 Input::Str { .. } => "rust_out".to_string(),
368 pub struct OutputFilenames {
369 pub out_directory: PathBuf,
370 pub out_filestem: String,
371 pub single_output_file: Option<PathBuf>,
373 pub outputs: OutputTypes,
376 /// Codegen unit names generated by the numbered naming scheme will contain this
377 /// marker right before the index of the codegen unit.
378 pub const NUMBERED_CODEGEN_UNIT_MARKER: &'static str = ".cgu-";
380 impl OutputFilenames {
381 pub fn path(&self, flavor: OutputType) -> PathBuf {
382 self.outputs.get(&flavor).and_then(|p| p.to_owned())
383 .or_else(|| self.single_output_file.clone())
384 .unwrap_or_else(|| self.temp_path(flavor, None))
387 /// Get the path where a compilation artifact of the given type for the
388 /// given codegen unit should be placed on disk. If codegen_unit_name is
389 /// None, a path distinct from those of any codegen unit will be generated.
390 pub fn temp_path(&self,
392 codegen_unit_name: Option<&str>)
394 let extension = flavor.extension();
395 self.temp_path_ext(extension, codegen_unit_name)
398 /// Like temp_path, but also supports things where there is no corresponding
399 /// OutputType, like no-opt-bitcode or lto-bitcode.
400 pub fn temp_path_ext(&self,
402 codegen_unit_name: Option<&str>)
404 let base = self.out_directory.join(&self.filestem());
406 let mut extension = String::new();
408 if let Some(codegen_unit_name) = codegen_unit_name {
409 if codegen_unit_name.contains(NUMBERED_CODEGEN_UNIT_MARKER) {
410 // If we use the numbered naming scheme for modules, we don't want
411 // the files to look like <crate-name><extra>.<crate-name>.<index>.<ext>
412 // but simply <crate-name><extra>.<index>.<ext>
413 let marker_offset = codegen_unit_name.rfind(NUMBERED_CODEGEN_UNIT_MARKER)
415 let index_offset = marker_offset + NUMBERED_CODEGEN_UNIT_MARKER.len();
416 extension.push_str(&codegen_unit_name[index_offset .. ]);
418 extension.push_str(codegen_unit_name);
423 if !extension.is_empty() {
424 extension.push_str(".");
427 extension.push_str(ext);
430 let path = base.with_extension(&extension[..]);
434 pub fn with_extension(&self, extension: &str) -> PathBuf {
435 self.out_directory.join(&self.filestem()).with_extension(extension)
438 pub fn filestem(&self) -> String {
439 format!("{}{}", self.out_filestem, self.extra)
443 pub fn host_triple() -> &'static str {
444 // Get the host triple out of the build environment. This ensures that our
445 // idea of the host triple is the same as for the set of libraries we've
446 // actually built. We can't just take LLVM's host triple because they
447 // normalize all ix86 architectures to i386.
449 // Instead of grabbing the host triple (for the current host), we grab (at
450 // compile time) the target triple that this rustc is built with and
451 // calling that (at runtime) the host triple.
452 (option_env!("CFG_COMPILER_HOST_TRIPLE")).
453 expect("CFG_COMPILER_HOST_TRIPLE")
456 /// Some reasonable defaults
457 pub fn basic_options() -> Options {
459 crate_types: Vec::new(),
460 optimize: OptLevel::No,
461 debuginfo: NoDebugInfo,
462 lint_opts: Vec::new(),
464 describe_lints: false,
465 output_types: OutputTypes(BTreeMap::new()),
466 search_paths: SearchPaths::new(),
468 target_triple: host_triple().to_string(),
471 debugging_opts: basic_debugging_options(),
473 cg: basic_codegen_options(),
474 error_format: ErrorOutputType::default(),
475 externs: Externs(BTreeMap::new()),
479 unstable_features: UnstableFeatures::Disallow,
480 debug_assertions: true,
481 actually_rustdoc: false,
486 /// True if there is a reason to build the dep graph.
487 pub fn build_dep_graph(&self) -> bool {
488 self.incremental.is_some() ||
489 self.debugging_opts.dump_dep_graph ||
490 self.debugging_opts.query_dep_graph
494 pub fn enable_dep_node_debug_strs(&self) -> bool {
495 cfg!(debug_assertions) &&
496 (self.debugging_opts.query_dep_graph || self.debugging_opts.incremental_info)
499 pub fn single_codegen_unit(&self) -> bool {
500 self.incremental.is_none() ||
501 self.cg.codegen_units == 1
504 pub fn file_path_mapping(&self) -> FilePathMapping {
505 FilePathMapping::new(
506 self.debugging_opts.remap_path_prefix_from.iter().zip(
507 self.debugging_opts.remap_path_prefix_to.iter()
508 ).map(|(src, dst)| (src.clone(), dst.clone())).collect()
513 // The type of entry function, so
514 // users can have their own entry
515 // functions that don't start a
517 #[derive(Copy, Clone, PartialEq)]
518 pub enum EntryFnType {
524 #[derive(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash, Debug)]
534 #[derive(Clone, Hash)]
536 SomePasses(Vec<String>),
541 pub fn is_empty(&self) -> bool {
543 SomePasses(ref v) => v.is_empty(),
549 /// Declare a macro that will define all CodegenOptions/DebuggingOptions fields and parsers all
550 /// at once. The goal of this macro is to define an interface that can be
551 /// programmatically used by the option parser in order to initialize the struct
552 /// without hardcoding field names all over the place.
554 /// The goal is to invoke this macro once with the correct fields, and then this
555 /// macro generates all necessary code. The main gotcha of this macro is the
556 /// cgsetters module which is a bunch of generated code to parse an option into
557 /// its respective field in the struct. There are a few hand-written parsers for
558 /// parsing specific types of values in this module.
559 macro_rules! options {
560 ($struct_name:ident, $setter_name:ident, $defaultfn:ident,
561 $buildfn:ident, $prefix:expr, $outputname:expr,
562 $stat:ident, $mod_desc:ident, $mod_set:ident,
563 $($opt:ident : $t:ty = (
566 [$dep_tracking_marker:ident $(($dep_warn_val:expr, $dep_warn_text:expr))*],
571 pub struct $struct_name { $(pub $opt: $t),* }
573 pub fn $defaultfn() -> $struct_name {
574 $struct_name { $($opt: $init),* }
577 pub fn $buildfn(matches: &getopts::Matches, error_format: ErrorOutputType) -> $struct_name
579 let mut op = $defaultfn();
580 for option in matches.opt_strs($prefix) {
581 let mut iter = option.splitn(2, '=');
582 let key = iter.next().unwrap();
583 let value = iter.next();
584 let option_to_lookup = key.replace("-", "_");
585 let mut found = false;
586 for &(candidate, setter, opt_type_desc, _) in $stat {
587 if option_to_lookup != candidate { continue }
588 if !setter(&mut op, value) {
589 match (value, opt_type_desc) {
590 (Some(..), None) => {
591 early_error(error_format, &format!("{} option `{}` takes no \
592 value", $outputname, key))
594 (None, Some(type_desc)) => {
595 early_error(error_format, &format!("{0} option `{1}` requires \
596 {2} ({3} {1}=<value>)",
600 (Some(value), Some(type_desc)) => {
601 early_error(error_format, &format!("incorrect value `{}` for {} \
602 option `{}` - {} was expected",
606 (None, None) => bug!()
613 early_error(error_format, &format!("unknown {} option: `{}`",
620 impl<'a> dep_tracking::DepTrackingHash for $struct_name {
622 fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType) {
623 let mut sub_hashes = BTreeMap::new();
628 [$dep_tracking_marker $($dep_warn_val,
632 dep_tracking::stable_hash(sub_hashes, hasher, error_format);
636 pub type $setter_name = fn(&mut $struct_name, v: Option<&str>) -> bool;
637 pub const $stat: &'static [(&'static str, $setter_name,
638 Option<&'static str>, &'static str)] =
639 &[ $( (stringify!($opt), $mod_set::$opt, $mod_desc::$parse, $desc) ),* ];
641 #[allow(non_upper_case_globals, dead_code)]
643 pub const parse_bool: Option<&'static str> = None;
644 pub const parse_opt_bool: Option<&'static str> =
645 Some("one of: `y`, `yes`, `on`, `n`, `no`, or `off`");
646 pub const parse_string: Option<&'static str> = Some("a string");
647 pub const parse_string_push: Option<&'static str> = Some("a string");
648 pub const parse_opt_string: Option<&'static str> = Some("a string");
649 pub const parse_list: Option<&'static str> = Some("a space-separated list of strings");
650 pub const parse_opt_list: Option<&'static str> = Some("a space-separated list of strings");
651 pub const parse_uint: Option<&'static str> = Some("a number");
652 pub const parse_passes: Option<&'static str> =
653 Some("a space-separated list of passes, or `all`");
654 pub const parse_opt_uint: Option<&'static str> =
656 pub const parse_panic_strategy: Option<&'static str> =
657 Some("either `panic` or `abort`");
658 pub const parse_relro_level: Option<&'static str> =
659 Some("one of: `full`, `partial`, or `off`");
660 pub const parse_sanitizer: Option<&'static str> =
661 Some("one of: `address`, `leak`, `memory` or `thread`");
662 pub const parse_linker_flavor: Option<&'static str> =
663 Some(::rustc_back::LinkerFlavor::one_of());
664 pub const parse_optimization_fuel: Option<&'static str> =
665 Some("crate=integer");
670 use super::{$struct_name, Passes, SomePasses, AllPasses, Sanitizer};
671 use rustc_back::{LinkerFlavor, PanicStrategy, RelroLevel};
674 pub fn $opt(cg: &mut $struct_name, v: Option<&str>) -> bool {
675 $parse(&mut cg.$opt, v)
679 fn parse_bool(slot: &mut bool, v: Option<&str>) -> bool {
682 None => { *slot = true; true }
686 fn parse_opt_bool(slot: &mut Option<bool>, v: Option<&str>) -> bool {
690 "n" | "no" | "off" => {
693 "y" | "yes" | "on" => {
696 _ => { return false; }
701 None => { *slot = Some(true); true }
705 fn parse_opt_string(slot: &mut Option<String>, v: Option<&str>) -> bool {
707 Some(s) => { *slot = Some(s.to_string()); true },
712 fn parse_string(slot: &mut String, v: Option<&str>) -> bool {
714 Some(s) => { *slot = s.to_string(); true },
719 fn parse_string_push(slot: &mut Vec<String>, v: Option<&str>) -> bool {
721 Some(s) => { slot.push(s.to_string()); true },
726 fn parse_list(slot: &mut Vec<String>, v: Option<&str>)
730 for s in s.split_whitespace() {
731 slot.push(s.to_string());
739 fn parse_opt_list(slot: &mut Option<Vec<String>>, v: Option<&str>)
743 let v = s.split_whitespace().map(|s| s.to_string()).collect();
751 fn parse_uint(slot: &mut usize, v: Option<&str>) -> bool {
752 match v.and_then(|s| s.parse().ok()) {
753 Some(i) => { *slot = i; true },
758 fn parse_opt_uint(slot: &mut Option<usize>, v: Option<&str>) -> bool {
760 Some(s) => { *slot = s.parse().ok(); slot.is_some() }
761 None => { *slot = None; true }
765 fn parse_passes(slot: &mut Passes, v: Option<&str>) -> bool {
772 let mut passes = vec![];
773 if parse_list(&mut passes, v) {
774 *slot = SomePasses(passes);
783 fn parse_panic_strategy(slot: &mut Option<PanicStrategy>, v: Option<&str>) -> bool {
785 Some("unwind") => *slot = Some(PanicStrategy::Unwind),
786 Some("abort") => *slot = Some(PanicStrategy::Abort),
792 fn parse_relro_level(slot: &mut Option<RelroLevel>, v: Option<&str>) -> bool {
795 match s.parse::<RelroLevel>() {
796 Ok(level) => *slot = Some(level),
805 fn parse_sanitizer(slote: &mut Option<Sanitizer>, v: Option<&str>) -> bool {
807 Some("address") => *slote = Some(Sanitizer::Address),
808 Some("leak") => *slote = Some(Sanitizer::Leak),
809 Some("memory") => *slote = Some(Sanitizer::Memory),
810 Some("thread") => *slote = Some(Sanitizer::Thread),
816 fn parse_linker_flavor(slote: &mut Option<LinkerFlavor>, v: Option<&str>) -> bool {
817 match v.and_then(LinkerFlavor::from_str) {
818 Some(lf) => *slote = Some(lf),
824 fn parse_optimization_fuel(slot: &mut Option<(String, u64)>, v: Option<&str>) -> bool {
828 let parts = s.split('=').collect::<Vec<_>>();
829 if parts.len() != 2 { return false; }
830 let crate_name = parts[0].to_string();
831 let fuel = parts[1].parse::<u64>();
832 if fuel.is_err() { return false; }
833 *slot = Some((crate_name, fuel.unwrap()));
841 options! {CodegenOptions, CodegenSetter, basic_codegen_options,
842 build_codegen_options, "C", "codegen",
843 CG_OPTIONS, cg_type_desc, cgsetters,
844 ar: Option<String> = (None, parse_opt_string, [UNTRACKED],
845 "tool to assemble archives with"),
846 linker: Option<String> = (None, parse_opt_string, [UNTRACKED],
847 "system linker to link outputs with"),
848 link_arg: Vec<String> = (vec![], parse_string_push, [UNTRACKED],
849 "a single extra argument to append to the linker invocation (can be used several times)"),
850 link_args: Option<Vec<String>> = (None, parse_opt_list, [UNTRACKED],
851 "extra arguments to append to the linker invocation (space separated)"),
852 link_dead_code: bool = (false, parse_bool, [UNTRACKED],
853 "don't let linker strip dead code (turning it on can be used for code coverage)"),
854 lto: bool = (false, parse_bool, [TRACKED],
855 "perform LLVM link-time optimizations"),
856 target_cpu: Option<String> = (None, parse_opt_string, [TRACKED],
857 "select target processor (rustc --print target-cpus for details)"),
858 target_feature: String = ("".to_string(), parse_string, [TRACKED],
859 "target specific attributes (rustc --print target-features for details)"),
860 passes: Vec<String> = (Vec::new(), parse_list, [TRACKED],
861 "a list of extra LLVM passes to run (space separated)"),
862 llvm_args: Vec<String> = (Vec::new(), parse_list, [TRACKED],
863 "a list of arguments to pass to llvm (space separated)"),
864 save_temps: bool = (false, parse_bool, [UNTRACKED_WITH_WARNING(true,
865 "`-C save-temps` might not produce all requested temporary products \
866 when incremental compilation is enabled.")],
867 "save all temporary output files during compilation"),
868 rpath: bool = (false, parse_bool, [UNTRACKED],
869 "set rpath values in libs/exes"),
870 overflow_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
871 "use overflow checks for integer arithmetic"),
872 no_prepopulate_passes: bool = (false, parse_bool, [TRACKED],
873 "don't pre-populate the pass manager with a list of passes"),
874 no_vectorize_loops: bool = (false, parse_bool, [TRACKED],
875 "don't run the loop vectorization optimization passes"),
876 no_vectorize_slp: bool = (false, parse_bool, [TRACKED],
877 "don't run LLVM's SLP vectorization pass"),
878 soft_float: bool = (false, parse_bool, [TRACKED],
879 "use soft float ABI (*eabihf targets only)"),
880 prefer_dynamic: bool = (false, parse_bool, [TRACKED],
881 "prefer dynamic linking to static linking"),
882 no_integrated_as: bool = (false, parse_bool, [TRACKED],
883 "use an external assembler rather than LLVM's integrated one"),
884 no_redzone: Option<bool> = (None, parse_opt_bool, [TRACKED],
885 "disable the use of the redzone"),
886 relocation_model: Option<String> = (None, parse_opt_string, [TRACKED],
887 "choose the relocation model to use (rustc --print relocation-models for details)"),
888 code_model: Option<String> = (None, parse_opt_string, [TRACKED],
889 "choose the code model to use (rustc --print code-models for details)"),
890 metadata: Vec<String> = (Vec::new(), parse_list, [TRACKED],
891 "metadata to mangle symbol names with"),
892 extra_filename: String = ("".to_string(), parse_string, [UNTRACKED],
893 "extra data to put in each output filename"),
894 codegen_units: usize = (1, parse_uint, [UNTRACKED],
895 "divide crate into N units to optimize in parallel"),
896 remark: Passes = (SomePasses(Vec::new()), parse_passes, [UNTRACKED],
897 "print remarks for these optimization passes (space separated, or \"all\")"),
898 no_stack_check: bool = (false, parse_bool, [UNTRACKED],
899 "the --no-stack-check flag is deprecated and does nothing"),
900 debuginfo: Option<usize> = (None, parse_opt_uint, [TRACKED],
901 "debug info emission level, 0 = no debug info, 1 = line tables only, \
902 2 = full debug info with variable and type information"),
903 opt_level: Option<String> = (None, parse_opt_string, [TRACKED],
904 "optimize with possible levels 0-3, s, or z"),
905 debug_assertions: Option<bool> = (None, parse_opt_bool, [TRACKED],
906 "explicitly enable the cfg(debug_assertions) directive"),
907 inline_threshold: Option<usize> = (None, parse_opt_uint, [TRACKED],
908 "set the inlining threshold for"),
909 panic: Option<PanicStrategy> = (None, parse_panic_strategy,
910 [TRACKED], "panic strategy to compile crate with"),
913 options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
914 build_debugging_options, "Z", "debugging",
915 DB_OPTIONS, db_type_desc, dbsetters,
916 verbose: bool = (false, parse_bool, [UNTRACKED],
917 "in general, enable more debug printouts"),
918 span_free_formats: bool = (false, parse_bool, [UNTRACKED],
919 "when debug-printing compiler state, do not include spans"), // o/w tests have closure@path
920 identify_regions: bool = (false, parse_bool, [UNTRACKED],
921 "make unnamed regions display as '# (where # is some non-ident unique id)"),
922 borrowck_mir: bool = (false, parse_bool, [UNTRACKED],
923 "implicitly treat functions as if they have `#[rustc_mir_borrowck]` attribute"),
924 time_passes: bool = (false, parse_bool, [UNTRACKED],
925 "measure time of each rustc pass"),
926 count_llvm_insns: bool = (false, parse_bool,
927 [UNTRACKED_WITH_WARNING(true,
928 "The output generated by `-Z count_llvm_insns` might not be reliable \
929 when used with incremental compilation")],
930 "count where LLVM instrs originate"),
931 time_llvm_passes: bool = (false, parse_bool, [UNTRACKED_WITH_WARNING(true,
932 "The output of `-Z time-llvm-passes` will only reflect timings of \
933 re-translated modules when used with incremental compilation" )],
934 "measure time of each LLVM pass"),
935 input_stats: bool = (false, parse_bool, [UNTRACKED],
936 "gather statistics about the input"),
937 trans_stats: bool = (false, parse_bool, [UNTRACKED_WITH_WARNING(true,
938 "The output of `-Z trans-stats` might not be accurate when incremental \
939 compilation is enabled")],
940 "gather trans statistics"),
941 asm_comments: bool = (false, parse_bool, [TRACKED],
942 "generate comments into the assembly (may change behavior)"),
943 no_verify: bool = (false, parse_bool, [TRACKED],
944 "skip LLVM verification"),
945 borrowck_stats: bool = (false, parse_bool, [UNTRACKED],
946 "gather borrowck statistics"),
947 no_landing_pads: bool = (false, parse_bool, [TRACKED],
948 "omit landing pads for unwinding"),
949 debug_llvm: bool = (false, parse_bool, [UNTRACKED],
950 "enable debug output from LLVM"),
951 meta_stats: bool = (false, parse_bool, [UNTRACKED],
952 "gather metadata statistics"),
953 print_link_args: bool = (false, parse_bool, [UNTRACKED],
954 "print the arguments passed to the linker"),
955 print_llvm_passes: bool = (false, parse_bool, [UNTRACKED],
956 "prints the llvm optimization passes being run"),
957 ast_json: bool = (false, parse_bool, [UNTRACKED],
958 "print the AST as JSON and halt"),
959 ast_json_noexpand: bool = (false, parse_bool, [UNTRACKED],
960 "print the pre-expansion AST as JSON and halt"),
961 ls: bool = (false, parse_bool, [UNTRACKED],
962 "list the symbols defined by a library crate"),
963 save_analysis: bool = (false, parse_bool, [UNTRACKED],
964 "write syntax and type analysis (in JSON format) information, in \
965 addition to normal output"),
966 print_move_fragments: bool = (false, parse_bool, [UNTRACKED],
967 "print out move-fragment data for every fn"),
968 flowgraph_print_loans: bool = (false, parse_bool, [UNTRACKED],
969 "include loan analysis data in --unpretty flowgraph output"),
970 flowgraph_print_moves: bool = (false, parse_bool, [UNTRACKED],
971 "include move analysis data in --unpretty flowgraph output"),
972 flowgraph_print_assigns: bool = (false, parse_bool, [UNTRACKED],
973 "include assignment analysis data in --unpretty flowgraph output"),
974 flowgraph_print_all: bool = (false, parse_bool, [UNTRACKED],
975 "include all dataflow analysis data in --unpretty flowgraph output"),
976 print_region_graph: bool = (false, parse_bool, [UNTRACKED],
977 "prints region inference graph. \
978 Use with RUST_REGION_GRAPH=help for more info"),
979 parse_only: bool = (false, parse_bool, [UNTRACKED],
980 "parse only; do not compile, assemble, or link"),
981 no_trans: bool = (false, parse_bool, [TRACKED],
982 "run all passes except translation; no output"),
983 treat_err_as_bug: bool = (false, parse_bool, [TRACKED],
984 "treat all errors that occur as bugs"),
985 continue_parse_after_error: bool = (false, parse_bool, [TRACKED],
986 "attempt to recover from parse errors (experimental)"),
987 incremental: Option<String> = (None, parse_opt_string, [UNTRACKED],
988 "enable incremental compilation (experimental)"),
989 incremental_cc: bool = (true, parse_bool, [UNTRACKED],
990 "enable cross-crate incremental compilation (even more experimental)"),
991 incremental_info: bool = (false, parse_bool, [UNTRACKED],
992 "print high-level information about incremental reuse (or the lack thereof)"),
993 incremental_dump_hash: bool = (false, parse_bool, [UNTRACKED],
994 "dump hash information in textual format to stdout"),
995 dump_dep_graph: bool = (false, parse_bool, [UNTRACKED],
996 "dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv)"),
997 query_dep_graph: bool = (false, parse_bool, [UNTRACKED],
998 "enable queries of the dependency graph for regression testing"),
999 profile_queries: bool = (false, parse_bool, [UNTRACKED],
1000 "trace and profile the queries of the incremental compilation framework"),
1001 profile_queries_and_keys: bool = (false, parse_bool, [UNTRACKED],
1002 "trace and profile the queries and keys of the incremental compilation framework"),
1003 no_analysis: bool = (false, parse_bool, [UNTRACKED],
1004 "parse and expand the source, but run no analysis"),
1005 extra_plugins: Vec<String> = (Vec::new(), parse_list, [TRACKED],
1006 "load extra plugins"),
1007 unstable_options: bool = (false, parse_bool, [UNTRACKED],
1008 "adds unstable command line options to rustc interface"),
1009 force_overflow_checks: Option<bool> = (None, parse_opt_bool, [TRACKED],
1010 "force overflow checks on or off"),
1011 trace_macros: bool = (false, parse_bool, [UNTRACKED],
1012 "for every macro invocation, print its name and arguments"),
1013 debug_macros: bool = (false, parse_bool, [TRACKED],
1014 "emit line numbers debug info inside macros"),
1015 enable_nonzeroing_move_hints: bool = (false, parse_bool, [TRACKED],
1016 "force nonzeroing move optimization on"),
1017 keep_hygiene_data: bool = (false, parse_bool, [UNTRACKED],
1018 "don't clear the hygiene data after analysis"),
1019 keep_ast: bool = (false, parse_bool, [UNTRACKED],
1020 "keep the AST after lowering it to HIR"),
1021 show_span: Option<String> = (None, parse_opt_string, [TRACKED],
1022 "show spans for compiler debugging (expr|pat|ty)"),
1023 print_type_sizes: bool = (false, parse_bool, [UNTRACKED],
1024 "print layout information for each type encountered"),
1025 print_trans_items: Option<String> = (None, parse_opt_string, [UNTRACKED],
1026 "print the result of the translation item collection pass"),
1027 mir_opt_level: usize = (1, parse_uint, [TRACKED],
1028 "set the MIR optimization level (0-3, default: 1)"),
1029 dump_mir: Option<String> = (None, parse_opt_string, [UNTRACKED],
1030 "dump MIR state at various points in translation"),
1031 dump_mir_dir: Option<String> = (None, parse_opt_string, [UNTRACKED],
1032 "the directory the MIR is dumped into"),
1033 dump_mir_exclude_pass_number: bool = (false, parse_bool, [UNTRACKED],
1034 "if set, exclude the pass number when dumping MIR (used in tests)"),
1035 mir_emit_validate: usize = (0, parse_uint, [TRACKED],
1036 "emit Validate MIR statements, interpreted e.g. by miri (0: do not emit; 1: if function \
1037 contains unsafe block, only validate arguments; 2: always emit full validation)"),
1038 perf_stats: bool = (false, parse_bool, [UNTRACKED],
1039 "print some performance-related statistics"),
1040 hir_stats: bool = (false, parse_bool, [UNTRACKED],
1041 "print some statistics about AST and HIR"),
1042 mir_stats: bool = (false, parse_bool, [UNTRACKED],
1043 "print some statistics about MIR"),
1044 always_encode_mir: bool = (false, parse_bool, [TRACKED],
1045 "encode MIR of all functions into the crate metadata"),
1046 osx_rpath_install_name: bool = (false, parse_bool, [TRACKED],
1047 "pass `-install_name @rpath/...` to the macOS linker"),
1048 sanitizer: Option<Sanitizer> = (None, parse_sanitizer, [TRACKED],
1050 linker_flavor: Option<LinkerFlavor> = (None, parse_linker_flavor, [UNTRACKED],
1052 fuel: Option<(String, u64)> = (None, parse_optimization_fuel, [TRACKED],
1053 "Set the optimization fuel quota for a crate."),
1054 print_fuel: Option<String> = (None, parse_opt_string, [TRACKED],
1055 "Make Rustc print the total optimization fuel used by a crate."),
1056 remap_path_prefix_from: Vec<String> = (vec![], parse_string_push, [TRACKED],
1057 "add a source pattern to the file path remapping config"),
1058 remap_path_prefix_to: Vec<String> = (vec![], parse_string_push, [TRACKED],
1059 "add a mapping target to the file path remapping config"),
1060 force_unstable_if_unmarked: bool = (false, parse_bool, [TRACKED],
1061 "force all crates to be `rustc_private` unstable"),
1062 pre_link_arg: Vec<String> = (vec![], parse_string_push, [UNTRACKED],
1063 "a single extra argument to prepend the linker invocation (can be used several times)"),
1064 pre_link_args: Option<Vec<String>> = (None, parse_opt_list, [UNTRACKED],
1065 "extra arguments to prepend to the linker invocation (space separated)"),
1066 profile: bool = (false, parse_bool, [TRACKED],
1067 "insert profiling code"),
1068 relro_level: Option<RelroLevel> = (None, parse_relro_level, [TRACKED],
1069 "choose which RELRO level to use"),
1070 nll: bool = (false, parse_bool, [UNTRACKED],
1071 "run the non-lexical lifetimes MIR pass"),
1072 trans_time_graph: bool = (false, parse_bool, [UNTRACKED],
1073 "generate a graphical HTML report of time spent in trans and LLVM"),
1076 pub fn default_lib_output() -> CrateType {
1080 pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
1081 let end = &sess.target.target.target_endian;
1082 let arch = &sess.target.target.arch;
1083 let wordsz = &sess.target.target.target_pointer_width;
1084 let os = &sess.target.target.target_os;
1085 let env = &sess.target.target.target_env;
1086 let vendor = &sess.target.target.target_vendor;
1087 let min_atomic_width = sess.target.target.min_atomic_width();
1088 let max_atomic_width = sess.target.target.max_atomic_width();
1090 let mut ret = HashSet::new();
1092 ret.insert((Symbol::intern("target_os"), Some(Symbol::intern(os))));
1093 if let Some(ref fam) = sess.target.target.options.target_family {
1094 ret.insert((Symbol::intern("target_family"), Some(Symbol::intern(fam))));
1095 if fam == "windows" || fam == "unix" {
1096 ret.insert((Symbol::intern(fam), None));
1099 ret.insert((Symbol::intern("target_arch"), Some(Symbol::intern(arch))));
1100 ret.insert((Symbol::intern("target_endian"), Some(Symbol::intern(end))));
1101 ret.insert((Symbol::intern("target_pointer_width"), Some(Symbol::intern(wordsz))));
1102 ret.insert((Symbol::intern("target_env"), Some(Symbol::intern(env))));
1103 ret.insert((Symbol::intern("target_vendor"), Some(Symbol::intern(vendor))));
1104 if sess.target.target.options.has_elf_tls {
1105 ret.insert((Symbol::intern("target_thread_local"), None));
1107 for &i in &[8, 16, 32, 64, 128] {
1108 if i >= min_atomic_width && i <= max_atomic_width {
1109 let s = i.to_string();
1110 ret.insert((Symbol::intern("target_has_atomic"), Some(Symbol::intern(&s))));
1112 ret.insert((Symbol::intern("target_has_atomic"), Some(Symbol::intern("ptr"))));
1116 if sess.opts.debug_assertions {
1117 ret.insert((Symbol::intern("debug_assertions"), None));
1119 if sess.opts.crate_types.contains(&CrateTypeProcMacro) {
1120 ret.insert((Symbol::intern("proc_macro"), None));
1125 pub fn build_configuration(sess: &Session,
1126 mut user_cfg: ast::CrateConfig)
1127 -> ast::CrateConfig {
1128 // Combine the configuration requested by the session (command line) with
1129 // some default and generated configuration items
1130 let default_cfg = default_configuration(sess);
1131 // If the user wants a test runner, then add the test cfg
1133 user_cfg.insert((Symbol::intern("test"), None));
1135 user_cfg.extend(default_cfg.iter().cloned());
1139 pub fn build_target_config(opts: &Options, sp: &Handler) -> Config {
1140 let target = match Target::search(&opts.target_triple) {
1143 sp.struct_fatal(&format!("Error loading target specification: {}", e))
1144 .help("Use `--print target-list` for a list of built-in targets")
1150 let (int_type, uint_type) = match &target.target_pointer_width[..] {
1151 "16" => (ast::IntTy::I16, ast::UintTy::U16),
1152 "32" => (ast::IntTy::I32, ast::UintTy::U32),
1153 "64" => (ast::IntTy::I64, ast::UintTy::U64),
1154 w => panic!(sp.fatal(&format!("target specification was invalid: \
1155 unrecognized target-pointer-width {}", w))),
1165 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
1166 pub enum OptionStability {
1172 pub struct RustcOptGroup {
1173 pub apply: Box<Fn(&mut getopts::Options) -> &mut getopts::Options>,
1174 pub name: &'static str,
1175 pub stability: OptionStability,
1178 impl RustcOptGroup {
1179 pub fn is_stable(&self) -> bool {
1180 self.stability == OptionStability::Stable
1183 pub fn stable<F>(name: &'static str, f: F) -> RustcOptGroup
1184 where F: Fn(&mut getopts::Options) -> &mut getopts::Options + 'static,
1189 stability: OptionStability::Stable,
1193 pub fn unstable<F>(name: &'static str, f: F) -> RustcOptGroup
1194 where F: Fn(&mut getopts::Options) -> &mut getopts::Options + 'static,
1199 stability: OptionStability::Unstable,
1204 // The `opt` local module holds wrappers around the `getopts` API that
1205 // adds extra rustc-specific metadata to each option; such metadata
1206 // is exposed by . The public
1207 // functions below ending with `_u` are the functions that return
1208 // *unstable* options, i.e. options that are only enabled when the
1209 // user also passes the `-Z unstable-options` debugging flag.
1211 // The `fn opt_u` etc below are written so that we can use them
1212 // in the future; do not warn about them not being used right now.
1213 #![allow(dead_code)]
1216 use super::RustcOptGroup;
1218 pub type R = RustcOptGroup;
1219 pub type S = &'static str;
1221 fn stable<F>(name: S, f: F) -> R
1222 where F: Fn(&mut getopts::Options) -> &mut getopts::Options + 'static
1224 RustcOptGroup::stable(name, f)
1227 fn unstable<F>(name: S, f: F) -> R
1228 where F: Fn(&mut getopts::Options) -> &mut getopts::Options + 'static
1230 RustcOptGroup::unstable(name, f)
1233 fn longer(a: S, b: S) -> S {
1234 if a.len() > b.len() {
1241 pub fn opt_s(a: S, b: S, c: S, d: S) -> R {
1242 stable(longer(a, b), move |opts| opts.optopt(a, b, c, d))
1244 pub fn multi_s(a: S, b: S, c: S, d: S) -> R {
1245 stable(longer(a, b), move |opts| opts.optmulti(a, b, c, d))
1247 pub fn flag_s(a: S, b: S, c: S) -> R {
1248 stable(longer(a, b), move |opts| opts.optflag(a, b, c))
1250 pub fn flagopt_s(a: S, b: S, c: S, d: S) -> R {
1251 stable(longer(a, b), move |opts| opts.optflagopt(a, b, c, d))
1253 pub fn flagmulti_s(a: S, b: S, c: S) -> R {
1254 stable(longer(a, b), move |opts| opts.optflagmulti(a, b, c))
1257 pub fn opt(a: S, b: S, c: S, d: S) -> R {
1258 unstable(longer(a, b), move |opts| opts.optopt(a, b, c, d))
1260 pub fn multi(a: S, b: S, c: S, d: S) -> R {
1261 unstable(longer(a, b), move |opts| opts.optmulti(a, b, c, d))
1263 pub fn flag(a: S, b: S, c: S) -> R {
1264 unstable(longer(a, b), move |opts| opts.optflag(a, b, c))
1266 pub fn flagopt(a: S, b: S, c: S, d: S) -> R {
1267 unstable(longer(a, b), move |opts| opts.optflagopt(a, b, c, d))
1269 pub fn flagmulti(a: S, b: S, c: S) -> R {
1270 unstable(longer(a, b), move |opts| opts.optflagmulti(a, b, c))
1274 /// Returns the "short" subset of the rustc command line options,
1275 /// including metadata for each option, such as whether the option is
1276 /// part of the stable long-term interface for rustc.
1277 pub fn rustc_short_optgroups() -> Vec<RustcOptGroup> {
1279 opt::flag_s("h", "help", "Display this message"),
1280 opt::multi_s("", "cfg", "Configure the compilation environment", "SPEC"),
1281 opt::multi_s("L", "", "Add a directory to the library search path. The
1282 optional KIND can be one of dependency, crate, native,
1283 framework or all (the default).", "[KIND=]PATH"),
1284 opt::multi_s("l", "", "Link the generated crate(s) to the specified native
1285 library NAME. The optional KIND can be one of
1286 static, dylib, or framework. If omitted, dylib is
1287 assumed.", "[KIND=]NAME"),
1288 opt::multi_s("", "crate-type", "Comma separated list of types of crates
1289 for the compiler to emit",
1290 "[bin|lib|rlib|dylib|cdylib|staticlib|proc-macro]"),
1291 opt::opt_s("", "crate-name", "Specify the name of the crate being built",
1293 opt::multi_s("", "emit", "Comma separated list of types of output for \
1294 the compiler to emit",
1295 "[asm|llvm-bc|llvm-ir|obj|metadata|link|dep-info|mir]"),
1296 opt::multi_s("", "print", "Comma separated list of compiler information to \
1298 "[crate-name|file-names|sysroot|cfg|target-list|\
1299 target-cpus|target-features|relocation-models|\
1300 code-models|target-spec-json|native-static-deps]"),
1301 opt::flagmulti_s("g", "", "Equivalent to -C debuginfo=2"),
1302 opt::flagmulti_s("O", "", "Equivalent to -C opt-level=2"),
1303 opt::opt_s("o", "", "Write output to <filename>", "FILENAME"),
1304 opt::opt_s("", "out-dir", "Write output to compiler-chosen filename \
1306 opt::opt_s("", "explain", "Provide a detailed explanation of an error \
1308 opt::flag_s("", "test", "Build a test harness"),
1309 opt::opt_s("", "target", "Target triple for which the code is compiled", "TARGET"),
1310 opt::multi_s("W", "warn", "Set lint warnings", "OPT"),
1311 opt::multi_s("A", "allow", "Set lint allowed", "OPT"),
1312 opt::multi_s("D", "deny", "Set lint denied", "OPT"),
1313 opt::multi_s("F", "forbid", "Set lint forbidden", "OPT"),
1314 opt::multi_s("", "cap-lints", "Set the most restrictive lint level. \
1315 More restrictive lints are capped at this \
1317 opt::multi_s("C", "codegen", "Set a codegen option", "OPT[=VALUE]"),
1318 opt::flag_s("V", "version", "Print version info and exit"),
1319 opt::flag_s("v", "verbose", "Use verbose output"),
1323 /// Returns all rustc command line options, including metadata for
1324 /// each option, such as whether the option is part of the stable
1325 /// long-term interface for rustc.
1326 pub fn rustc_optgroups() -> Vec<RustcOptGroup> {
1327 let mut opts = rustc_short_optgroups();
1329 opt::multi_s("", "extern", "Specify where an external rust library is located",
1331 opt::opt_s("", "sysroot", "Override the system root", "PATH"),
1332 opt::multi("Z", "", "Set internal debugging options", "FLAG"),
1333 opt::opt_s("", "error-format",
1334 "How errors and other messages are produced",
1336 opt::opt_s("", "color", "Configure coloring of output:
1337 auto = colorize, if output goes to a tty (default);
1338 always = always colorize output;
1339 never = never colorize output", "auto|always|never"),
1341 opt::flagopt("", "pretty",
1342 "Pretty-print the input instead of compiling;
1343 valid types are: `normal` (un-annotated source),
1344 `expanded` (crates expanded), or
1345 `expanded,identified` (fully parenthesized, AST nodes with IDs).",
1347 opt::flagopt("", "unpretty",
1348 "Present the input source, unstable (and less-pretty) variants;
1349 valid types are any of the types for `--pretty`, as well as:
1350 `flowgraph=<nodeid>` (graphviz formatted flowgraph for node),
1351 `everybody_loops` (all function bodies replaced with `loop {}`),
1352 `hir` (the HIR), `hir,identified`, or
1353 `hir,typed` (HIR with types for each node).",
1359 // Convert strings provided as --cfg [cfgspec] into a crate_cfg
1360 pub fn parse_cfgspecs(cfgspecs: Vec<String> ) -> ast::CrateConfig {
1361 cfgspecs.into_iter().map(|s| {
1362 let sess = parse::ParseSess::new(FilePathMapping::empty());
1364 parse::new_parser_from_source_str(&sess, "cfgspec".to_string(), s.to_string());
1366 let meta_item = panictry!(parser.parse_meta_item());
1368 if parser.token != token::Eof {
1369 early_error(ErrorOutputType::default(), &format!("invalid --cfg argument: {}", s))
1370 } else if meta_item.is_meta_item_list() {
1372 format!("invalid predicate in --cfg command line argument: `{}`", meta_item.name());
1373 early_error(ErrorOutputType::default(), &msg)
1376 (meta_item.name(), meta_item.value_str())
1377 }).collect::<ast::CrateConfig>()
1380 pub fn build_session_options_and_crate_config(matches: &getopts::Matches)
1381 -> (Options, ast::CrateConfig) {
1382 let color = match matches.opt_str("color").as_ref().map(|s| &s[..]) {
1383 Some("auto") => ColorConfig::Auto,
1384 Some("always") => ColorConfig::Always,
1385 Some("never") => ColorConfig::Never,
1387 None => ColorConfig::Auto,
1390 early_error(ErrorOutputType::default(), &format!("argument for --color must be auto, \
1391 always or never (instead was `{}`)",
1396 // We need the opts_present check because the driver will send us Matches
1397 // with only stable options if no unstable options are used. Since error-format
1398 // is unstable, it will not be present. We have to use opts_present not
1399 // opt_present because the latter will panic.
1400 let error_format = if matches.opts_present(&["error-format".to_owned()]) {
1401 match matches.opt_str("error-format").as_ref().map(|s| &s[..]) {
1402 Some("human") => ErrorOutputType::HumanReadable(color),
1403 Some("json") => ErrorOutputType::Json,
1405 None => ErrorOutputType::HumanReadable(color),
1408 early_error(ErrorOutputType::HumanReadable(color),
1409 &format!("argument for --error-format must be human or json (instead \
1415 ErrorOutputType::HumanReadable(color)
1418 let unparsed_crate_types = matches.opt_strs("crate-type");
1419 let crate_types = parse_crate_types_from_list(unparsed_crate_types)
1420 .unwrap_or_else(|e| early_error(error_format, &e[..]));
1422 let mut lint_opts = vec![];
1423 let mut describe_lints = false;
1425 for &level in &[lint::Allow, lint::Warn, lint::Deny, lint::Forbid] {
1426 for lint_name in matches.opt_strs(level.as_str()) {
1427 if lint_name == "help" {
1428 describe_lints = true;
1430 lint_opts.push((lint_name.replace("-", "_"), level));
1435 let lint_cap = matches.opt_str("cap-lints").map(|cap| {
1436 lint::Level::from_str(&cap).unwrap_or_else(|| {
1437 early_error(error_format, &format!("unknown lint level: `{}`", cap))
1441 let debugging_opts = build_debugging_options(matches, error_format);
1443 let mut output_types = BTreeMap::new();
1444 if !debugging_opts.parse_only {
1445 for list in matches.opt_strs("emit") {
1446 for output_type in list.split(',') {
1447 let mut parts = output_type.splitn(2, '=');
1448 let output_type = match parts.next().unwrap() {
1449 "asm" => OutputType::Assembly,
1450 "llvm-ir" => OutputType::LlvmAssembly,
1451 "mir" => OutputType::Mir,
1452 "llvm-bc" => OutputType::Bitcode,
1453 "obj" => OutputType::Object,
1454 "metadata" => OutputType::Metadata,
1455 "link" => OutputType::Exe,
1456 "dep-info" => OutputType::DepInfo,
1458 early_error(error_format, &format!("unknown emission type: `{}`",
1462 let path = parts.next().map(PathBuf::from);
1463 output_types.insert(output_type, path);
1467 if output_types.is_empty() {
1468 output_types.insert(OutputType::Exe, None);
1471 let remap_path_prefix_sources = debugging_opts.remap_path_prefix_from.len();
1472 let remap_path_prefix_targets = debugging_opts.remap_path_prefix_from.len();
1474 if remap_path_prefix_targets < remap_path_prefix_sources {
1475 for source in &debugging_opts.remap_path_prefix_from[remap_path_prefix_targets..] {
1476 early_error(error_format,
1477 &format!("option `-Zremap-path-prefix-from='{}'` does not have \
1478 a corresponding `-Zremap-path-prefix-to`", source))
1480 } else if remap_path_prefix_targets > remap_path_prefix_sources {
1481 for target in &debugging_opts.remap_path_prefix_to[remap_path_prefix_sources..] {
1482 early_error(error_format,
1483 &format!("option `-Zremap-path-prefix-to='{}'` does not have \
1484 a corresponding `-Zremap-path-prefix-from`", target))
1488 let mut cg = build_codegen_options(matches, error_format);
1490 // Issue #30063: if user requests llvm-related output to one
1491 // particular path, disable codegen-units.
1492 if matches.opt_present("o") && cg.codegen_units != 1 {
1493 let incompatible: Vec<_> = output_types.iter()
1494 .map(|ot_path| ot_path.0)
1496 !ot.is_compatible_with_codegen_units_and_single_output_file()
1498 if !incompatible.is_empty() {
1499 for ot in &incompatible {
1500 early_warn(error_format, &format!("--emit={} with -o incompatible with \
1501 -C codegen-units=N for N > 1",
1504 early_warn(error_format, "resetting to default -C codegen-units=1");
1505 cg.codegen_units = 1;
1509 if cg.codegen_units < 1 {
1510 early_error(error_format, "Value for codegen units must be a positive nonzero integer");
1513 // It's possible that we have `codegen_units > 1` but only one item in
1514 // `trans.modules`. We could theoretically proceed and do LTO in that
1515 // case, but it would be confusing to have the validity of
1516 // `-Z lto -C codegen-units=2` depend on details of the crate being
1517 // compiled, so we complain regardless.
1518 if cg.lto && cg.codegen_units > 1 {
1519 // This case is impossible to handle because LTO expects to be able
1520 // to combine the entire crate and all its dependencies into a
1521 // single compilation unit, but each codegen unit is in a separate
1522 // LLVM context, so they can't easily be combined.
1523 early_error(error_format, "can't perform LTO when using multiple codegen units");
1526 if cg.lto && debugging_opts.incremental.is_some() {
1527 early_error(error_format, "can't perform LTO when compiling incrementally");
1530 let mut prints = Vec::<PrintRequest>::new();
1531 if cg.target_cpu.as_ref().map_or(false, |s| s == "help") {
1532 prints.push(PrintRequest::TargetCPUs);
1533 cg.target_cpu = None;
1535 if cg.target_feature == "help" {
1536 prints.push(PrintRequest::TargetFeatures);
1537 cg.target_feature = "".to_string();
1539 if cg.relocation_model.as_ref().map_or(false, |s| s == "help") {
1540 prints.push(PrintRequest::RelocationModels);
1541 cg.relocation_model = None;
1543 if cg.code_model.as_ref().map_or(false, |s| s == "help") {
1544 prints.push(PrintRequest::CodeModels);
1545 cg.code_model = None;
1550 let sysroot_opt = matches.opt_str("sysroot").map(|m| PathBuf::from(&m));
1551 let target = matches.opt_str("target").unwrap_or(
1552 host_triple().to_string());
1554 if matches.opt_present("O") {
1555 if cg.opt_level.is_some() {
1556 early_error(error_format, "-O and -C opt-level both provided");
1560 match (cg.opt_level.as_ref().map(String::as_ref),
1561 nightly_options::is_nightly_build()) {
1562 (None, _) => OptLevel::No,
1563 (Some("0"), _) => OptLevel::No,
1564 (Some("1"), _) => OptLevel::Less,
1565 (Some("2"), _) => OptLevel::Default,
1566 (Some("3"), _) => OptLevel::Aggressive,
1567 (Some("s"), true) => OptLevel::Size,
1568 (Some("z"), true) => OptLevel::SizeMin,
1569 (Some("s"), false) | (Some("z"), false) => {
1570 early_error(error_format, &format!("the optimizations s or z are only \
1571 accepted on the nightly compiler"));
1574 early_error(error_format, &format!("optimization level needs to be \
1575 between 0-3 (instead was `{}`)",
1581 let debug_assertions = cg.debug_assertions.unwrap_or(opt_level == OptLevel::No);
1582 let debuginfo = if matches.opt_present("g") {
1583 if cg.debuginfo.is_some() {
1584 early_error(error_format, "-g and -C debuginfo both provided");
1588 match cg.debuginfo {
1589 None | Some(0) => NoDebugInfo,
1590 Some(1) => LimitedDebugInfo,
1591 Some(2) => FullDebugInfo,
1593 early_error(error_format, &format!("debug info level needs to be between \
1594 0-2 (instead was `{}`)",
1600 let mut search_paths = SearchPaths::new();
1601 for s in &matches.opt_strs("L") {
1602 search_paths.add_path(&s[..], error_format);
1605 let libs = matches.opt_strs("l").into_iter().map(|s| {
1606 // Parse string of the form "[KIND=]lib[:new_name]",
1607 // where KIND is one of "dylib", "framework", "static".
1608 let mut parts = s.splitn(2, '=');
1609 let kind = parts.next().unwrap();
1610 let (name, kind) = match (parts.next(), kind) {
1611 (None, name) => (name, None),
1612 (Some(name), "dylib") => (name, Some(cstore::NativeUnknown)),
1613 (Some(name), "framework") => (name, Some(cstore::NativeFramework)),
1614 (Some(name), "static") => (name, Some(cstore::NativeStatic)),
1615 (Some(name), "static-nobundle") => (name, Some(cstore::NativeStaticNobundle)),
1617 early_error(error_format, &format!("unknown library kind `{}`, expected \
1618 one of dylib, framework, or static",
1622 if kind == Some(cstore::NativeStaticNobundle) && !nightly_options::is_nightly_build() {
1623 early_error(error_format, &format!("the library kind 'static-nobundle' is only \
1624 accepted on the nightly compiler"));
1626 let mut name_parts = name.splitn(2, ':');
1627 let name = name_parts.next().unwrap();
1628 let new_name = name_parts.next();
1629 (name.to_string(), new_name.map(|n| n.to_string()), kind)
1632 let cfg = parse_cfgspecs(matches.opt_strs("cfg"));
1633 let test = matches.opt_present("test");
1635 prints.extend(matches.opt_strs("print").into_iter().map(|s| {
1637 "crate-name" => PrintRequest::CrateName,
1638 "file-names" => PrintRequest::FileNames,
1639 "sysroot" => PrintRequest::Sysroot,
1640 "cfg" => PrintRequest::Cfg,
1641 "target-list" => PrintRequest::TargetList,
1642 "target-cpus" => PrintRequest::TargetCPUs,
1643 "target-features" => PrintRequest::TargetFeatures,
1644 "relocation-models" => PrintRequest::RelocationModels,
1645 "code-models" => PrintRequest::CodeModels,
1646 "native-static-libs" => PrintRequest::NativeStaticLibs,
1647 "target-spec-json" => {
1648 if nightly_options::is_unstable_enabled(matches) {
1649 PrintRequest::TargetSpec
1651 early_error(error_format,
1652 &format!("the `-Z unstable-options` flag must also be passed to \
1653 enable the target-spec-json print option"));
1657 early_error(error_format, &format!("unknown print request `{}`", req))
1662 if !cg.remark.is_empty() && debuginfo == NoDebugInfo {
1663 early_warn(error_format, "-C remark will not show source locations without \
1667 let mut externs = BTreeMap::new();
1668 for arg in &matches.opt_strs("extern") {
1669 let mut parts = arg.splitn(2, '=');
1670 let name = match parts.next() {
1672 None => early_error(error_format, "--extern value must not be empty"),
1674 let location = match parts.next() {
1676 None => early_error(error_format, "--extern value must be of the format `foo=bar`"),
1679 externs.entry(name.to_string())
1680 .or_insert_with(BTreeSet::new)
1681 .insert(location.to_string());
1684 let crate_name = matches.opt_str("crate-name");
1686 let incremental = debugging_opts.incremental.as_ref().map(|m| PathBuf::from(m));
1690 optimize: opt_level,
1695 output_types: OutputTypes(output_types),
1697 maybe_sysroot: sysroot_opt,
1698 target_triple: target,
1705 externs: Externs(externs),
1709 unstable_features: UnstableFeatures::from_environment(),
1711 actually_rustdoc: false,
1716 pub fn parse_crate_types_from_list(list_list: Vec<String>)
1717 -> Result<Vec<CrateType>, String> {
1718 let mut crate_types: Vec<CrateType> = Vec::new();
1719 for unparsed_crate_type in &list_list {
1720 for part in unparsed_crate_type.split(',') {
1721 let new_part = match part {
1722 "lib" => default_lib_output(),
1723 "rlib" => CrateTypeRlib,
1724 "staticlib" => CrateTypeStaticlib,
1725 "dylib" => CrateTypeDylib,
1726 "cdylib" => CrateTypeCdylib,
1727 "bin" => CrateTypeExecutable,
1728 "proc-macro" => CrateTypeProcMacro,
1730 return Err(format!("unknown crate type: `{}`",
1734 if !crate_types.contains(&new_part) {
1735 crate_types.push(new_part)
1743 pub mod nightly_options {
1745 use syntax::feature_gate::UnstableFeatures;
1746 use super::{ErrorOutputType, OptionStability, RustcOptGroup};
1747 use session::early_error;
1749 pub fn is_unstable_enabled(matches: &getopts::Matches) -> bool {
1750 is_nightly_build() && matches.opt_strs("Z").iter().any(|x| *x == "unstable-options")
1753 pub fn is_nightly_build() -> bool {
1754 UnstableFeatures::from_environment().is_nightly_build()
1757 pub fn check_nightly_options(matches: &getopts::Matches, flags: &[RustcOptGroup]) {
1758 let has_z_unstable_option = matches.opt_strs("Z").iter().any(|x| *x == "unstable-options");
1759 let really_allows_unstable_options = UnstableFeatures::from_environment()
1760 .is_nightly_build();
1762 for opt in flags.iter() {
1763 if opt.stability == OptionStability::Stable {
1766 if !matches.opt_present(opt.name) {
1769 if opt.name != "Z" && !has_z_unstable_option {
1770 early_error(ErrorOutputType::default(),
1771 &format!("the `-Z unstable-options` flag must also be passed to enable \
1775 if really_allows_unstable_options {
1778 match opt.stability {
1779 OptionStability::Unstable => {
1780 let msg = format!("the option `{}` is only accepted on the \
1781 nightly compiler", opt.name);
1782 early_error(ErrorOutputType::default(), &msg);
1784 OptionStability::Stable => {}
1790 impl fmt::Display for CrateType {
1791 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1793 CrateTypeExecutable => "bin".fmt(f),
1794 CrateTypeDylib => "dylib".fmt(f),
1795 CrateTypeRlib => "rlib".fmt(f),
1796 CrateTypeStaticlib => "staticlib".fmt(f),
1797 CrateTypeCdylib => "cdylib".fmt(f),
1798 CrateTypeProcMacro => "proc-macro".fmt(f),
1803 /// Commandline arguments passed to the compiler have to be incorporated with
1804 /// the dependency tracking system for incremental compilation. This module
1805 /// provides some utilities to make this more convenient.
1807 /// The values of all commandline arguments that are relevant for dependency
1808 /// tracking are hashed into a single value that determines whether the
1809 /// incremental compilation cache can be re-used or not. This hashing is done
1810 /// via the DepTrackingHash trait defined below, since the standard Hash
1811 /// implementation might not be suitable (e.g. arguments are stored in a Vec,
1812 /// the hash of which is order dependent, but we might not want the order of
1813 /// arguments to make a difference for the hash).
1815 /// However, since the value provided by Hash::hash often *is* suitable,
1816 /// especially for primitive types, there is the
1817 /// impl_dep_tracking_hash_via_hash!() macro that allows to simply reuse the
1818 /// Hash implementation for DepTrackingHash. It's important though that
1819 /// we have an opt-in scheme here, so one is hopefully forced to think about
1820 /// how the hash should be calculated when adding a new commandline argument.
1824 use session::search_paths::{PathKind, SearchPaths};
1825 use std::collections::BTreeMap;
1826 use std::hash::Hash;
1827 use std::path::PathBuf;
1828 use std::collections::hash_map::DefaultHasher;
1829 use super::{Passes, CrateType, OptLevel, DebugInfoLevel,
1830 OutputTypes, Externs, ErrorOutputType, Sanitizer};
1831 use syntax::feature_gate::UnstableFeatures;
1832 use rustc_back::{PanicStrategy, RelroLevel};
1834 pub trait DepTrackingHash {
1835 fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType);
1838 macro_rules! impl_dep_tracking_hash_via_hash {
1840 impl DepTrackingHash for $t {
1841 fn hash(&self, hasher: &mut DefaultHasher, _: ErrorOutputType) {
1842 Hash::hash(self, hasher);
1848 macro_rules! impl_dep_tracking_hash_for_sortable_vec_of {
1850 impl DepTrackingHash for Vec<$t> {
1851 fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType) {
1852 let mut elems: Vec<&$t> = self.iter().collect();
1854 Hash::hash(&elems.len(), hasher);
1855 for (index, elem) in elems.iter().enumerate() {
1856 Hash::hash(&index, hasher);
1857 DepTrackingHash::hash(*elem, hasher, error_format);
1864 impl_dep_tracking_hash_via_hash!(bool);
1865 impl_dep_tracking_hash_via_hash!(usize);
1866 impl_dep_tracking_hash_via_hash!(u64);
1867 impl_dep_tracking_hash_via_hash!(String);
1868 impl_dep_tracking_hash_via_hash!(lint::Level);
1869 impl_dep_tracking_hash_via_hash!(Option<bool>);
1870 impl_dep_tracking_hash_via_hash!(Option<usize>);
1871 impl_dep_tracking_hash_via_hash!(Option<String>);
1872 impl_dep_tracking_hash_via_hash!(Option<(String, u64)>);
1873 impl_dep_tracking_hash_via_hash!(Option<PanicStrategy>);
1874 impl_dep_tracking_hash_via_hash!(Option<RelroLevel>);
1875 impl_dep_tracking_hash_via_hash!(Option<lint::Level>);
1876 impl_dep_tracking_hash_via_hash!(Option<PathBuf>);
1877 impl_dep_tracking_hash_via_hash!(Option<cstore::NativeLibraryKind>);
1878 impl_dep_tracking_hash_via_hash!(CrateType);
1879 impl_dep_tracking_hash_via_hash!(PanicStrategy);
1880 impl_dep_tracking_hash_via_hash!(RelroLevel);
1881 impl_dep_tracking_hash_via_hash!(Passes);
1882 impl_dep_tracking_hash_via_hash!(OptLevel);
1883 impl_dep_tracking_hash_via_hash!(DebugInfoLevel);
1884 impl_dep_tracking_hash_via_hash!(UnstableFeatures);
1885 impl_dep_tracking_hash_via_hash!(Externs);
1886 impl_dep_tracking_hash_via_hash!(OutputTypes);
1887 impl_dep_tracking_hash_via_hash!(cstore::NativeLibraryKind);
1888 impl_dep_tracking_hash_via_hash!(Sanitizer);
1889 impl_dep_tracking_hash_via_hash!(Option<Sanitizer>);
1891 impl_dep_tracking_hash_for_sortable_vec_of!(String);
1892 impl_dep_tracking_hash_for_sortable_vec_of!(CrateType);
1893 impl_dep_tracking_hash_for_sortable_vec_of!((String, lint::Level));
1894 impl_dep_tracking_hash_for_sortable_vec_of!((String, Option<String>,
1895 Option<cstore::NativeLibraryKind>));
1896 impl_dep_tracking_hash_for_sortable_vec_of!((String, u64));
1897 impl DepTrackingHash for SearchPaths {
1898 fn hash(&self, hasher: &mut DefaultHasher, _: ErrorOutputType) {
1899 let mut elems: Vec<_> = self
1900 .iter(PathKind::All)
1903 Hash::hash(&elems, hasher);
1907 impl<T1, T2> DepTrackingHash for (T1, T2)
1908 where T1: DepTrackingHash,
1911 fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType) {
1912 Hash::hash(&0, hasher);
1913 DepTrackingHash::hash(&self.0, hasher, error_format);
1914 Hash::hash(&1, hasher);
1915 DepTrackingHash::hash(&self.1, hasher, error_format);
1919 impl<T1, T2, T3> DepTrackingHash for (T1, T2, T3)
1920 where T1: DepTrackingHash,
1921 T2: DepTrackingHash,
1924 fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType) {
1925 Hash::hash(&0, hasher);
1926 DepTrackingHash::hash(&self.0, hasher, error_format);
1927 Hash::hash(&1, hasher);
1928 DepTrackingHash::hash(&self.1, hasher, error_format);
1929 Hash::hash(&2, hasher);
1930 DepTrackingHash::hash(&self.2, hasher, error_format);
1934 // This is a stable hash because BTreeMap is a sorted container
1935 pub fn stable_hash(sub_hashes: BTreeMap<&'static str, &DepTrackingHash>,
1936 hasher: &mut DefaultHasher,
1937 error_format: ErrorOutputType) {
1938 for (key, sub_hash) in sub_hashes {
1939 // Using Hash::hash() instead of DepTrackingHash::hash() is fine for
1940 // the keys, as they are just plain strings
1941 Hash::hash(&key.len(), hasher);
1942 Hash::hash(key, hasher);
1943 sub_hash.hash(hasher, error_format);
1950 use dep_graph::DepGraph;
1954 use middle::cstore::{self, DummyCrateStore};
1955 use session::config::{build_configuration, build_session_options_and_crate_config};
1956 use session::build_session;
1957 use std::collections::{BTreeMap, BTreeSet};
1958 use std::iter::FromIterator;
1959 use std::path::PathBuf;
1961 use super::{OutputType, OutputTypes, Externs};
1962 use rustc_back::{PanicStrategy, RelroLevel};
1963 use syntax::symbol::Symbol;
1965 fn optgroups() -> getopts::Options {
1966 let mut opts = getopts::Options::new();
1967 for group in super::rustc_optgroups() {
1968 (group.apply)(&mut opts);
1973 fn mk_map<K: Ord, V>(entries: Vec<(K, V)>) -> BTreeMap<K, V> {
1974 BTreeMap::from_iter(entries.into_iter())
1977 fn mk_set<V: Ord>(entries: Vec<V>) -> BTreeSet<V> {
1978 BTreeSet::from_iter(entries.into_iter())
1981 // When the user supplies --test we should implicitly supply --cfg test
1983 fn test_switch_implies_cfg_test() {
1984 let dep_graph = DepGraph::new(false);
1986 &match optgroups().parse(&["--test".to_string()]) {
1988 Err(f) => panic!("test_switch_implies_cfg_test: {}", f)
1990 let registry = errors::registry::Registry::new(&[]);
1991 let (sessopts, cfg) = build_session_options_and_crate_config(matches);
1992 let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore));
1993 let cfg = build_configuration(&sess, cfg);
1994 assert!(cfg.contains(&(Symbol::intern("test"), None)));
1997 // When the user supplies --test and --cfg test, don't implicitly add
1998 // another --cfg test
2000 fn test_switch_implies_cfg_test_unless_cfg_test() {
2001 let dep_graph = DepGraph::new(false);
2003 &match optgroups().parse(&["--test".to_string(), "--cfg=test".to_string()]) {
2006 panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f)
2009 let registry = errors::registry::Registry::new(&[]);
2010 let (sessopts, cfg) = build_session_options_and_crate_config(matches);
2011 let sess = build_session(sessopts, &dep_graph, None, registry,
2012 Rc::new(DummyCrateStore));
2013 let cfg = build_configuration(&sess, cfg);
2014 let mut test_items = cfg.iter().filter(|&&(name, _)| name == "test");
2015 assert!(test_items.next().is_some());
2016 assert!(test_items.next().is_none());
2020 fn test_can_print_warnings() {
2021 let dep_graph = DepGraph::new(false);
2023 let matches = optgroups().parse(&[
2024 "-Awarnings".to_string()
2026 let registry = errors::registry::Registry::new(&[]);
2027 let (sessopts, _) = build_session_options_and_crate_config(&matches);
2028 let sess = build_session(sessopts, &dep_graph, None, registry,
2029 Rc::new(DummyCrateStore));
2030 assert!(!sess.diagnostic().can_emit_warnings);
2034 let matches = optgroups().parse(&[
2035 "-Awarnings".to_string(),
2036 "-Dwarnings".to_string()
2038 let registry = errors::registry::Registry::new(&[]);
2039 let (sessopts, _) = build_session_options_and_crate_config(&matches);
2040 let sess = build_session(sessopts, &dep_graph, None, registry,
2041 Rc::new(DummyCrateStore));
2042 assert!(sess.diagnostic().can_emit_warnings);
2046 let matches = optgroups().parse(&[
2047 "-Adead_code".to_string()
2049 let registry = errors::registry::Registry::new(&[]);
2050 let (sessopts, _) = build_session_options_and_crate_config(&matches);
2051 let sess = build_session(sessopts, &dep_graph, None, registry,
2052 Rc::new(DummyCrateStore));
2053 assert!(sess.diagnostic().can_emit_warnings);
2058 fn test_output_types_tracking_hash_different_paths() {
2059 let mut v1 = super::basic_options();
2060 let mut v2 = super::basic_options();
2061 let mut v3 = super::basic_options();
2063 v1.output_types = OutputTypes::new(&[(OutputType::Exe,
2064 Some(PathBuf::from("./some/thing")))]);
2065 v2.output_types = OutputTypes::new(&[(OutputType::Exe,
2066 Some(PathBuf::from("/some/thing")))]);
2067 v3.output_types = OutputTypes::new(&[(OutputType::Exe, None)]);
2069 assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
2070 assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
2071 assert!(v2.dep_tracking_hash() != v3.dep_tracking_hash());
2074 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2075 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2076 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2080 fn test_output_types_tracking_hash_different_construction_order() {
2081 let mut v1 = super::basic_options();
2082 let mut v2 = super::basic_options();
2084 v1.output_types = OutputTypes::new(&[
2085 (OutputType::Exe, Some(PathBuf::from("./some/thing"))),
2086 (OutputType::Bitcode, Some(PathBuf::from("./some/thing.bc"))),
2089 v2.output_types = OutputTypes::new(&[
2090 (OutputType::Bitcode, Some(PathBuf::from("./some/thing.bc"))),
2091 (OutputType::Exe, Some(PathBuf::from("./some/thing"))),
2094 assert_eq!(v1.dep_tracking_hash(), v2.dep_tracking_hash());
2097 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2101 fn test_externs_tracking_hash_different_values() {
2102 let mut v1 = super::basic_options();
2103 let mut v2 = super::basic_options();
2104 let mut v3 = super::basic_options();
2106 v1.externs = Externs::new(mk_map(vec![
2107 (String::from("a"), mk_set(vec![String::from("b"),
2108 String::from("c")])),
2109 (String::from("d"), mk_set(vec![String::from("e"),
2110 String::from("f")])),
2113 v2.externs = Externs::new(mk_map(vec![
2114 (String::from("a"), mk_set(vec![String::from("b"),
2115 String::from("c")])),
2116 (String::from("X"), mk_set(vec![String::from("e"),
2117 String::from("f")])),
2120 v3.externs = Externs::new(mk_map(vec![
2121 (String::from("a"), mk_set(vec![String::from("b"),
2122 String::from("c")])),
2123 (String::from("d"), mk_set(vec![String::from("X"),
2124 String::from("f")])),
2127 assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
2128 assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
2129 assert!(v2.dep_tracking_hash() != v3.dep_tracking_hash());
2132 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2133 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2134 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2138 fn test_externs_tracking_hash_different_construction_order() {
2139 let mut v1 = super::basic_options();
2140 let mut v2 = super::basic_options();
2141 let mut v3 = super::basic_options();
2143 v1.externs = Externs::new(mk_map(vec![
2144 (String::from("a"), mk_set(vec![String::from("b"),
2145 String::from("c")])),
2146 (String::from("d"), mk_set(vec![String::from("e"),
2147 String::from("f")])),
2150 v2.externs = Externs::new(mk_map(vec![
2151 (String::from("d"), mk_set(vec![String::from("e"),
2152 String::from("f")])),
2153 (String::from("a"), mk_set(vec![String::from("b"),
2154 String::from("c")])),
2157 v3.externs = Externs::new(mk_map(vec![
2158 (String::from("a"), mk_set(vec![String::from("b"),
2159 String::from("c")])),
2160 (String::from("d"), mk_set(vec![String::from("f"),
2161 String::from("e")])),
2164 assert_eq!(v1.dep_tracking_hash(), v2.dep_tracking_hash());
2165 assert_eq!(v1.dep_tracking_hash(), v3.dep_tracking_hash());
2166 assert_eq!(v2.dep_tracking_hash(), v3.dep_tracking_hash());
2169 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2170 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2171 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2175 fn test_lints_tracking_hash_different_values() {
2176 let mut v1 = super::basic_options();
2177 let mut v2 = super::basic_options();
2178 let mut v3 = super::basic_options();
2180 v1.lint_opts = vec![(String::from("a"), lint::Allow),
2181 (String::from("b"), lint::Warn),
2182 (String::from("c"), lint::Deny),
2183 (String::from("d"), lint::Forbid)];
2185 v2.lint_opts = vec![(String::from("a"), lint::Allow),
2186 (String::from("b"), lint::Warn),
2187 (String::from("X"), lint::Deny),
2188 (String::from("d"), lint::Forbid)];
2190 v3.lint_opts = vec![(String::from("a"), lint::Allow),
2191 (String::from("b"), lint::Warn),
2192 (String::from("c"), lint::Forbid),
2193 (String::from("d"), lint::Deny)];
2195 assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
2196 assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
2197 assert!(v2.dep_tracking_hash() != v3.dep_tracking_hash());
2200 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2201 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2202 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2206 fn test_lints_tracking_hash_different_construction_order() {
2207 let mut v1 = super::basic_options();
2208 let mut v2 = super::basic_options();
2210 v1.lint_opts = vec![(String::from("a"), lint::Allow),
2211 (String::from("b"), lint::Warn),
2212 (String::from("c"), lint::Deny),
2213 (String::from("d"), lint::Forbid)];
2215 v2.lint_opts = vec![(String::from("a"), lint::Allow),
2216 (String::from("c"), lint::Deny),
2217 (String::from("b"), lint::Warn),
2218 (String::from("d"), lint::Forbid)];
2220 assert_eq!(v1.dep_tracking_hash(), v2.dep_tracking_hash());
2223 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2224 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2228 fn test_search_paths_tracking_hash_different_values() {
2229 let mut v1 = super::basic_options();
2230 let mut v2 = super::basic_options();
2231 let mut v3 = super::basic_options();
2232 let mut v4 = super::basic_options();
2233 let mut v5 = super::basic_options();
2236 v1.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2237 v1.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2238 v1.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2239 v1.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2240 v1.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2243 v2.search_paths.add_path("native=XXX", super::ErrorOutputType::Json);
2244 v2.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2245 v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2246 v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2247 v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2250 v2.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2251 v2.search_paths.add_path("crate=XXX", super::ErrorOutputType::Json);
2252 v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2253 v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2254 v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2256 // Dependency changed
2257 v3.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2258 v3.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2259 v3.search_paths.add_path("dependency=XXX", super::ErrorOutputType::Json);
2260 v3.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2261 v3.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2263 // Framework changed
2264 v4.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2265 v4.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2266 v4.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2267 v4.search_paths.add_path("framework=XXX", super::ErrorOutputType::Json);
2268 v4.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2271 v5.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2272 v5.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2273 v5.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2274 v5.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2275 v5.search_paths.add_path("all=XXX", super::ErrorOutputType::Json);
2277 assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
2278 assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
2279 assert!(v1.dep_tracking_hash() != v4.dep_tracking_hash());
2280 assert!(v1.dep_tracking_hash() != v5.dep_tracking_hash());
2283 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2284 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2285 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2286 assert_eq!(v4.dep_tracking_hash(), v4.clone().dep_tracking_hash());
2287 assert_eq!(v5.dep_tracking_hash(), v5.clone().dep_tracking_hash());
2291 fn test_search_paths_tracking_hash_different_order() {
2292 let mut v1 = super::basic_options();
2293 let mut v2 = super::basic_options();
2294 let mut v3 = super::basic_options();
2295 let mut v4 = super::basic_options();
2298 v1.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2299 v1.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2300 v1.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2301 v1.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2302 v1.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2304 v2.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2305 v2.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2306 v2.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2307 v2.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2308 v2.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2310 v3.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2311 v3.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2312 v3.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2313 v3.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2314 v3.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2316 v4.search_paths.add_path("all=mno", super::ErrorOutputType::Json);
2317 v4.search_paths.add_path("native=abc", super::ErrorOutputType::Json);
2318 v4.search_paths.add_path("crate=def", super::ErrorOutputType::Json);
2319 v4.search_paths.add_path("dependency=ghi", super::ErrorOutputType::Json);
2320 v4.search_paths.add_path("framework=jkl", super::ErrorOutputType::Json);
2322 assert!(v1.dep_tracking_hash() == v2.dep_tracking_hash());
2323 assert!(v1.dep_tracking_hash() == v3.dep_tracking_hash());
2324 assert!(v1.dep_tracking_hash() == v4.dep_tracking_hash());
2327 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2328 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2329 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2330 assert_eq!(v4.dep_tracking_hash(), v4.clone().dep_tracking_hash());
2334 fn test_native_libs_tracking_hash_different_values() {
2335 let mut v1 = super::basic_options();
2336 let mut v2 = super::basic_options();
2337 let mut v3 = super::basic_options();
2338 let mut v4 = super::basic_options();
2341 v1.libs = vec![(String::from("a"), None, Some(cstore::NativeStatic)),
2342 (String::from("b"), None, Some(cstore::NativeFramework)),
2343 (String::from("c"), None, Some(cstore::NativeUnknown))];
2346 v2.libs = vec![(String::from("a"), None, Some(cstore::NativeStatic)),
2347 (String::from("X"), None, Some(cstore::NativeFramework)),
2348 (String::from("c"), None, Some(cstore::NativeUnknown))];
2351 v3.libs = vec![(String::from("a"), None, Some(cstore::NativeStatic)),
2352 (String::from("b"), None, Some(cstore::NativeStatic)),
2353 (String::from("c"), None, Some(cstore::NativeUnknown))];
2356 v4.libs = vec![(String::from("a"), None, Some(cstore::NativeStatic)),
2357 (String::from("b"), Some(String::from("X")), Some(cstore::NativeFramework)),
2358 (String::from("c"), None, Some(cstore::NativeUnknown))];
2360 assert!(v1.dep_tracking_hash() != v2.dep_tracking_hash());
2361 assert!(v1.dep_tracking_hash() != v3.dep_tracking_hash());
2362 assert!(v1.dep_tracking_hash() != v4.dep_tracking_hash());
2365 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2366 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2367 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2368 assert_eq!(v4.dep_tracking_hash(), v4.clone().dep_tracking_hash());
2372 fn test_native_libs_tracking_hash_different_order() {
2373 let mut v1 = super::basic_options();
2374 let mut v2 = super::basic_options();
2375 let mut v3 = super::basic_options();
2378 v1.libs = vec![(String::from("a"), None, Some(cstore::NativeStatic)),
2379 (String::from("b"), None, Some(cstore::NativeFramework)),
2380 (String::from("c"), None, Some(cstore::NativeUnknown))];
2382 v2.libs = vec![(String::from("b"), None, Some(cstore::NativeFramework)),
2383 (String::from("a"), None, Some(cstore::NativeStatic)),
2384 (String::from("c"), None, Some(cstore::NativeUnknown))];
2386 v3.libs = vec![(String::from("c"), None, Some(cstore::NativeUnknown)),
2387 (String::from("a"), None, Some(cstore::NativeStatic)),
2388 (String::from("b"), None, Some(cstore::NativeFramework))];
2390 assert!(v1.dep_tracking_hash() == v2.dep_tracking_hash());
2391 assert!(v1.dep_tracking_hash() == v3.dep_tracking_hash());
2392 assert!(v2.dep_tracking_hash() == v3.dep_tracking_hash());
2395 assert_eq!(v1.dep_tracking_hash(), v1.clone().dep_tracking_hash());
2396 assert_eq!(v2.dep_tracking_hash(), v2.clone().dep_tracking_hash());
2397 assert_eq!(v3.dep_tracking_hash(), v3.clone().dep_tracking_hash());
2401 fn test_codegen_options_tracking_hash() {
2402 let reference = super::basic_options();
2403 let mut opts = super::basic_options();
2405 // Make sure the changing an [UNTRACKED] option leaves the hash unchanged
2406 opts.cg.ar = Some(String::from("abc"));
2407 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2409 opts.cg.linker = Some(String::from("linker"));
2410 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2412 opts.cg.link_args = Some(vec![String::from("abc"), String::from("def")]);
2413 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2415 opts.cg.link_dead_code = true;
2416 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2418 opts.cg.rpath = true;
2419 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2421 opts.cg.extra_filename = String::from("extra-filename");
2422 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2424 opts.cg.codegen_units = 42;
2425 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2427 opts.cg.remark = super::SomePasses(vec![String::from("pass1"),
2428 String::from("pass2")]);
2429 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2431 opts.cg.save_temps = true;
2432 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2435 // Make sure changing a [TRACKED] option changes the hash
2436 opts = reference.clone();
2438 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2440 opts = reference.clone();
2441 opts.cg.target_cpu = Some(String::from("abc"));
2442 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2444 opts = reference.clone();
2445 opts.cg.target_feature = String::from("all the features, all of them");
2446 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2448 opts = reference.clone();
2449 opts.cg.passes = vec![String::from("1"), String::from("2")];
2450 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2452 opts = reference.clone();
2453 opts.cg.llvm_args = vec![String::from("1"), String::from("2")];
2454 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2456 opts = reference.clone();
2457 opts.cg.overflow_checks = Some(true);
2458 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2460 opts = reference.clone();
2461 opts.cg.no_prepopulate_passes = true;
2462 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2464 opts = reference.clone();
2465 opts.cg.no_vectorize_loops = true;
2466 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2468 opts = reference.clone();
2469 opts.cg.no_vectorize_slp = true;
2470 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2472 opts = reference.clone();
2473 opts.cg.soft_float = true;
2474 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2476 opts = reference.clone();
2477 opts.cg.prefer_dynamic = true;
2478 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2480 opts = reference.clone();
2481 opts.cg.no_integrated_as = true;
2482 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2484 opts = reference.clone();
2485 opts.cg.no_redzone = Some(true);
2486 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2488 opts = reference.clone();
2489 opts.cg.relocation_model = Some(String::from("relocation model"));
2490 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2492 opts = reference.clone();
2493 opts.cg.code_model = Some(String::from("code model"));
2494 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2496 opts = reference.clone();
2497 opts.cg.metadata = vec![String::from("A"), String::from("B")];
2498 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2500 opts = reference.clone();
2501 opts.cg.debuginfo = Some(0xdeadbeef);
2502 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2504 opts = reference.clone();
2505 opts.cg.debuginfo = Some(0xba5eba11);
2506 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2508 opts = reference.clone();
2509 opts.cg.debug_assertions = Some(true);
2510 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2512 opts = reference.clone();
2513 opts.cg.inline_threshold = Some(0xf007ba11);
2514 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2516 opts = reference.clone();
2517 opts.cg.panic = Some(PanicStrategy::Abort);
2518 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2522 fn test_debugging_options_tracking_hash() {
2523 let reference = super::basic_options();
2524 let mut opts = super::basic_options();
2526 // Make sure the changing an [UNTRACKED] option leaves the hash unchanged
2527 opts.debugging_opts.verbose = true;
2528 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2529 opts.debugging_opts.time_passes = true;
2530 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2531 opts.debugging_opts.count_llvm_insns = true;
2532 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2533 opts.debugging_opts.time_llvm_passes = true;
2534 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2535 opts.debugging_opts.input_stats = true;
2536 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2537 opts.debugging_opts.trans_stats = true;
2538 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2539 opts.debugging_opts.borrowck_stats = true;
2540 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2541 opts.debugging_opts.debug_llvm = true;
2542 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2543 opts.debugging_opts.meta_stats = true;
2544 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2545 opts.debugging_opts.print_link_args = true;
2546 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2547 opts.debugging_opts.print_llvm_passes = true;
2548 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2549 opts.debugging_opts.ast_json = true;
2550 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2551 opts.debugging_opts.ast_json_noexpand = true;
2552 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2553 opts.debugging_opts.ls = true;
2554 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2555 opts.debugging_opts.save_analysis = true;
2556 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2557 opts.debugging_opts.print_move_fragments = true;
2558 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2559 opts.debugging_opts.flowgraph_print_loans = true;
2560 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2561 opts.debugging_opts.flowgraph_print_moves = true;
2562 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2563 opts.debugging_opts.flowgraph_print_assigns = true;
2564 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2565 opts.debugging_opts.flowgraph_print_all = true;
2566 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2567 opts.debugging_opts.print_region_graph = true;
2568 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2569 opts.debugging_opts.parse_only = true;
2570 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2571 opts.debugging_opts.incremental = Some(String::from("abc"));
2572 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2573 opts.debugging_opts.dump_dep_graph = true;
2574 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2575 opts.debugging_opts.query_dep_graph = true;
2576 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2577 opts.debugging_opts.no_analysis = true;
2578 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2579 opts.debugging_opts.unstable_options = true;
2580 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2581 opts.debugging_opts.trace_macros = true;
2582 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2583 opts.debugging_opts.keep_hygiene_data = true;
2584 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2585 opts.debugging_opts.keep_ast = true;
2586 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2587 opts.debugging_opts.print_trans_items = Some(String::from("abc"));
2588 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2589 opts.debugging_opts.dump_mir = Some(String::from("abc"));
2590 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2591 opts.debugging_opts.dump_mir_dir = Some(String::from("abc"));
2592 assert_eq!(reference.dep_tracking_hash(), opts.dep_tracking_hash());
2594 // Make sure changing a [TRACKED] option changes the hash
2595 opts = reference.clone();
2596 opts.debugging_opts.asm_comments = true;
2597 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2599 opts = reference.clone();
2600 opts.debugging_opts.no_verify = true;
2601 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2603 opts = reference.clone();
2604 opts.debugging_opts.no_landing_pads = true;
2605 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2607 opts = reference.clone();
2608 opts.debugging_opts.no_trans = true;
2609 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2611 opts = reference.clone();
2612 opts.debugging_opts.treat_err_as_bug = true;
2613 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2615 opts = reference.clone();
2616 opts.debugging_opts.continue_parse_after_error = true;
2617 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2619 opts = reference.clone();
2620 opts.debugging_opts.extra_plugins = vec![String::from("plugin1"), String::from("plugin2")];
2621 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2623 opts = reference.clone();
2624 opts.debugging_opts.force_overflow_checks = Some(true);
2625 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2627 opts = reference.clone();
2628 opts.debugging_opts.enable_nonzeroing_move_hints = true;
2629 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2631 opts = reference.clone();
2632 opts.debugging_opts.show_span = Some(String::from("abc"));
2633 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2635 opts = reference.clone();
2636 opts.debugging_opts.mir_opt_level = 3;
2637 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());
2639 opts = reference.clone();
2640 opts.debugging_opts.relro_level = Some(RelroLevel::Full);
2641 assert!(reference.dep_tracking_hash() != opts.dep_tracking_hash());