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::OptLevel::*;
18 pub use self::OutputType::*;
19 pub use self::DebugInfoLevel::*;
21 use session::{early_error, Session};
22 use session::search_paths::SearchPaths;
24 use rustc_back::target::Target;
29 use syntax::ast::{IntTy, UintTy};
31 use syntax::attr::AttrMetaMethods;
32 use syntax::diagnostic::{ColorConfig, Auto, Always, Never, SpanHandler};
34 use syntax::parse::token::InternedString;
36 use std::collections::HashMap;
37 use std::collections::hash_map::Entry::{Occupied, Vacant};
46 pub uint_type: UintTy,
49 #[deriving(Clone, Copy, PartialEq)]
57 #[deriving(Clone, Copy, PartialEq)]
58 pub enum DebugInfoLevel {
64 #[deriving(Clone, Copy, PartialEq, PartialOrd, Ord, Eq)]
68 OutputTypeLlvmAssembly,
76 // The crate config requested for the session, which may be combined
77 // with additional crate configurations during the compile process
78 pub crate_types: Vec<CrateType>,
81 pub optimize: OptLevel,
82 pub debuginfo: DebugInfoLevel,
83 pub lint_opts: Vec<(String, lint::Level)>,
84 pub describe_lints: bool,
85 pub output_types: Vec<OutputType> ,
86 // This was mutable for rustpkg, which updates search paths based on the
87 // parsed code. It remains mutable in case its replacements wants to use
89 pub search_paths: SearchPaths,
90 pub libs: Vec<(String, cstore::NativeLibraryKind)>,
91 pub maybe_sysroot: Option<Path>,
92 pub target_triple: String,
93 // User-specified cfg meta items. The compiler itself will add additional
94 // items to the crate config, and during parsing the entire crate config
95 // will be added to the crate AST node. This should not be used for
96 // anything except building the full crate config prior to parsing.
97 pub cfg: ast::CrateConfig,
101 pub no_analysis: bool,
102 pub debugging_opts: u64,
103 /// Whether to write dependency files. It's (enabled, optional filename).
104 pub write_dependency_info: (bool, Option<Path>),
105 pub prints: Vec<PrintRequest>,
106 pub cg: CodegenOptions,
107 pub color: ColorConfig,
108 pub externs: HashMap<String, Vec<String>>,
109 pub crate_name: Option<String>,
110 /// An optional name to use as the crate for std during std injection,
111 /// written `extern crate std = "name"`. Default to "std". Used by
112 /// out-of-tree drivers.
113 pub alt_std_name: Option<String>
116 #[deriving(Clone, PartialEq, Eq)]
117 #[allow(missing_copy_implementations)]
118 pub enum PrintRequest {
125 /// Load source from file
127 /// The string is the source
132 pub fn filestem(&self) -> String {
134 Input::File(ref ifile) => ifile.filestem_str().unwrap().to_string(),
135 Input::Str(_) => "rust_out".to_string(),
141 pub struct OutputFilenames {
142 pub out_directory: Path,
143 pub out_filestem: String,
144 pub single_output_file: Option<Path>,
148 impl OutputFilenames {
149 pub fn path(&self, flavor: OutputType) -> Path {
150 match self.single_output_file {
151 Some(ref path) => return path.clone(),
154 self.temp_path(flavor)
157 pub fn temp_path(&self, flavor: OutputType) -> Path {
158 let base = self.out_directory.join(self.filestem());
160 OutputTypeBitcode => base.with_extension("bc"),
161 OutputTypeAssembly => base.with_extension("s"),
162 OutputTypeLlvmAssembly => base.with_extension("ll"),
163 OutputTypeObject => base.with_extension("o"),
164 OutputTypeDepInfo => base.with_extension("d"),
165 OutputTypeExe => base,
169 pub fn with_extension(&self, extension: &str) -> Path {
170 self.out_directory.join(self.filestem()).with_extension(extension)
173 pub fn filestem(&self) -> String {
174 format!("{}{}", self.out_filestem, self.extra)
178 pub fn host_triple() -> &'static str {
179 // Get the host triple out of the build environment. This ensures that our
180 // idea of the host triple is the same as for the set of libraries we've
181 // actually built. We can't just take LLVM's host triple because they
182 // normalize all ix86 architectures to i386.
184 // Instead of grabbing the host triple (for the current host), we grab (at
185 // compile time) the target triple that this rustc is built with and
186 // calling that (at runtime) the host triple.
187 (option_env!("CFG_COMPILER_HOST_TRIPLE")).
188 expect("CFG_COMPILER_HOST_TRIPLE")
191 /// Some reasonable defaults
192 pub fn basic_options() -> Options {
194 crate_types: Vec::new(),
197 debuginfo: NoDebugInfo,
198 lint_opts: Vec::new(),
199 describe_lints: false,
200 output_types: Vec::new(),
201 search_paths: SearchPaths::new(),
203 target_triple: host_triple().to_string(),
210 write_dependency_info: (false, None),
212 cg: basic_codegen_options(),
214 externs: HashMap::new(),
221 // The type of entry function, so
222 // users can have their own entry
223 // functions that don't start a
225 #[deriving(Copy, PartialEq)]
226 pub enum EntryFnType {
232 #[deriving(Copy, PartialEq, PartialOrd, Clone, Ord, Eq, Hash)]
240 macro_rules! debugging_opts {
241 ([ $opt:ident ] $cnt:expr ) => (
242 pub const $opt: u64 = 1 << $cnt;
244 ([ $opt:ident, $($rest:ident),* ] $cnt:expr ) => (
245 pub const $opt: u64 = 1 << $cnt;
246 debugging_opts! { [ $($rest),* ] $cnt + 1 }
272 PRINT_MOVE_FRAGMENTS,
273 FLOWGRAPH_PRINT_LOANS,
274 FLOWGRAPH_PRINT_MOVES,
275 FLOWGRAPH_PRINT_ASSIGNS,
287 pub fn debugging_opts_map() -> Vec<(&'static str, &'static str, u64)> {
288 vec![("verbose", "in general, enable more debug printouts", VERBOSE),
289 ("time-passes", "measure time of each rustc pass", TIME_PASSES),
290 ("count-llvm-insns", "count where LLVM \
291 instrs originate", COUNT_LLVM_INSNS),
292 ("time-llvm-passes", "measure time of each LLVM pass",
294 ("trans-stats", "gather trans statistics", TRANS_STATS),
295 ("asm-comments", "generate comments into the assembly (may change behavior)",
297 ("no-verify", "skip LLVM verification", NO_VERIFY),
298 ("borrowck-stats", "gather borrowck statistics", BORROWCK_STATS),
299 ("no-landing-pads", "omit landing pads for unwinding",
301 ("debug-llvm", "enable debug output from LLVM", DEBUG_LLVM),
302 ("show-span", "show spans for compiler debugging", SHOW_SPAN),
303 ("count-type-sizes", "count the sizes of aggregate types",
305 ("meta-stats", "gather metadata statistics", META_STATS),
306 ("print-link-args", "Print the arguments passed to the linker",
308 ("gc", "Garbage collect shared data (experimental)", GC),
309 ("print-llvm-passes",
310 "Prints the llvm optimization passes being run",
312 ("ast-json", "Print the AST as JSON and halt", AST_JSON),
313 ("ast-json-noexpand", "Print the pre-expansion AST as JSON and halt", AST_JSON_NOEXPAND),
314 ("ls", "List the symbols defined by a library crate", LS),
315 ("save-analysis", "Write syntax and type analysis information \
316 in addition to normal output", SAVE_ANALYSIS),
317 ("print-move-fragments", "Print out move-fragment data for every fn",
318 PRINT_MOVE_FRAGMENTS),
319 ("flowgraph-print-loans", "Include loan analysis data in \
320 --pretty flowgraph output", FLOWGRAPH_PRINT_LOANS),
321 ("flowgraph-print-moves", "Include move analysis data in \
322 --pretty flowgraph output", FLOWGRAPH_PRINT_MOVES),
323 ("flowgraph-print-assigns", "Include assignment analysis data in \
324 --pretty flowgraph output", FLOWGRAPH_PRINT_ASSIGNS),
325 ("flowgraph-print-all", "Include all dataflow analysis data in \
326 --pretty flowgraph output", FLOWGRAPH_PRINT_ALL),
327 ("print-region-graph", "Prints region inference graph. \
328 Use with RUST_REGION_GRAPH=help for more info",
330 ("parse-only", "Parse only; do not compile, assemble, or link", PARSE_ONLY),
331 ("no-trans", "Run all passes except translation; no output", NO_TRANS),
332 ("no-analysis", "Parse and expand the source, but run no analysis and",
334 ("unstable-options", "Adds unstable command line options to rustc interface",
336 ("print-enum-sizes", "Print the size of enums and their variants", PRINT_ENUM_SIZES),
342 SomePasses(Vec<String>),
347 pub fn is_empty(&self) -> bool {
349 SomePasses(ref v) => v.is_empty(),
355 /// Declare a macro that will define all CodegenOptions fields and parsers all
356 /// at once. The goal of this macro is to define an interface that can be
357 /// programmatically used by the option parser in order to initialize the struct
358 /// without hardcoding field names all over the place.
360 /// The goal is to invoke this macro once with the correct fields, and then this
361 /// macro generates all necessary code. The main gotcha of this macro is the
362 /// cgsetters module which is a bunch of generated code to parse an option into
363 /// its respective field in the struct. There are a few hand-written parsers for
364 /// parsing specific types of values in this module.
365 macro_rules! cgoptions {
366 ($($opt:ident : $t:ty = ($init:expr, $parse:ident, $desc:expr)),* ,) =>
369 pub struct CodegenOptions { $(pub $opt: $t),* }
371 pub fn basic_codegen_options() -> CodegenOptions {
372 CodegenOptions { $($opt: $init),* }
375 pub type CodegenSetter = fn(&mut CodegenOptions, v: Option<&str>) -> bool;
376 pub const CG_OPTIONS: &'static [(&'static str, CodegenSetter,
377 Option<&'static str>, &'static str)] =
378 &[ $( (stringify!($opt), cgsetters::$opt, cg_type_descs::$parse, $desc) ),* ];
380 #[allow(non_upper_case_globals)]
382 pub const parse_bool: Option<&'static str> = None;
383 pub const parse_opt_bool: Option<&'static str> = None;
384 pub const parse_string: Option<&'static str> = Some("a string");
385 pub const parse_opt_string: Option<&'static str> = Some("a string");
386 pub const parse_list: Option<&'static str> = Some("a space-separated list of strings");
387 pub const parse_opt_list: Option<&'static str> = Some("a space-separated list of strings");
388 pub const parse_uint: Option<&'static str> = Some("a number");
389 pub const parse_passes: Option<&'static str> =
390 Some("a space-separated list of passes, or `all`");
391 pub const parse_opt_uint: Option<&'static str> =
396 use super::{CodegenOptions, Passes, SomePasses, AllPasses};
397 use std::str::from_str;
400 pub fn $opt(cg: &mut CodegenOptions, v: Option<&str>) -> bool {
401 $parse(&mut cg.$opt, v)
405 fn parse_bool(slot: &mut bool, v: Option<&str>) -> bool {
408 None => { *slot = true; true }
412 fn parse_opt_bool(slot: &mut Option<bool>, v: Option<&str>) -> bool {
415 None => { *slot = Some(true); true }
419 fn parse_opt_string(slot: &mut Option<String>, v: Option<&str>) -> bool {
421 Some(s) => { *slot = Some(s.to_string()); true },
426 fn parse_string(slot: &mut String, v: Option<&str>) -> bool {
428 Some(s) => { *slot = s.to_string(); true },
433 fn parse_list(slot: &mut Vec<String>, v: Option<&str>)
438 slot.push(s.to_string());
446 fn parse_opt_list(slot: &mut Option<Vec<String>>, v: Option<&str>)
450 let v = s.words().map(|s| s.to_string()).collect();
458 fn parse_uint(slot: &mut uint, v: Option<&str>) -> bool {
459 match v.and_then(from_str) {
460 Some(i) => { *slot = i; true },
465 fn parse_opt_uint(slot: &mut Option<uint>, v: Option<&str>) -> bool {
467 Some(s) => { *slot = from_str(s); slot.is_some() }
468 None => { *slot = None; true }
472 fn parse_passes(slot: &mut Passes, v: Option<&str>) -> bool {
479 let mut passes = vec!();
480 if parse_list(&mut passes, v) {
481 *slot = SomePasses(passes);
493 ar: Option<String> = (None, parse_opt_string,
494 "tool to assemble archives with"),
495 linker: Option<String> = (None, parse_opt_string,
496 "system linker to link outputs with"),
497 link_args: Option<Vec<String>> = (None, parse_opt_list,
498 "extra arguments to pass to the linker (space separated)"),
499 lto: bool = (false, parse_bool,
500 "perform LLVM link-time optimizations"),
501 target_cpu: Option<String> = (None, parse_opt_string,
502 "select target processor (llc -mcpu=help for details)"),
503 target_feature: String = ("".to_string(), parse_string,
504 "target specific attributes (llc -mattr=help for details)"),
505 passes: Vec<String> = (Vec::new(), parse_list,
506 "a list of extra LLVM passes to run (space separated)"),
507 llvm_args: Vec<String> = (Vec::new(), parse_list,
508 "a list of arguments to pass to llvm (space separated)"),
509 save_temps: bool = (false, parse_bool,
510 "save all temporary output files during compilation"),
511 rpath: bool = (false, parse_bool,
512 "set rpath values in libs/exes"),
513 no_prepopulate_passes: bool = (false, parse_bool,
514 "don't pre-populate the pass manager with a list of passes"),
515 no_vectorize_loops: bool = (false, parse_bool,
516 "don't run the loop vectorization optimization passes"),
517 no_vectorize_slp: bool = (false, parse_bool,
518 "don't run LLVM's SLP vectorization pass"),
519 soft_float: bool = (false, parse_bool,
520 "generate software floating point library calls"),
521 prefer_dynamic: bool = (false, parse_bool,
522 "prefer dynamic linking to static linking"),
523 no_integrated_as: bool = (false, parse_bool,
524 "use an external assembler rather than LLVM's integrated one"),
525 no_redzone: Option<bool> = (None, parse_opt_bool,
526 "disable the use of the redzone"),
527 relocation_model: Option<String> = (None, parse_opt_string,
528 "choose the relocation model to use (llc -relocation-model for details)"),
529 code_model: Option<String> = (None, parse_opt_string,
530 "choose the code model to use (llc -code-model for details)"),
531 metadata: Vec<String> = (Vec::new(), parse_list,
532 "metadata to mangle symbol names with"),
533 extra_filename: String = ("".to_string(), parse_string,
534 "extra data to put in each output filename"),
535 codegen_units: uint = (1, parse_uint,
536 "divide crate into N units to optimize in parallel"),
537 remark: Passes = (SomePasses(Vec::new()), parse_passes,
538 "print remarks for these optimization passes (space separated, or \"all\")"),
539 no_stack_check: bool = (false, parse_bool,
540 "disable checks for stack exhaustion (a memory-safety hazard!)"),
541 debuginfo: Option<uint> = (None, parse_opt_uint,
542 "debug info emission level, 0 = no debug info, 1 = line tables only, \
543 2 = full debug info with variable and type information"),
544 opt_level: Option<uint> = (None, parse_opt_uint,
545 "Optimize with possible levels 0-3"),
548 pub fn build_codegen_options(matches: &getopts::Matches) -> CodegenOptions
550 let mut cg = basic_codegen_options();
551 for option in matches.opt_strs("C").into_iter() {
552 let mut iter = option.splitn(1, '=');
553 let key = iter.next().unwrap();
554 let value = iter.next();
555 let option_to_lookup = key.replace("-", "_");
556 let mut found = false;
557 for &(candidate, setter, opt_type_desc, _) in CG_OPTIONS.iter() {
558 if option_to_lookup != candidate { continue }
559 if !setter(&mut cg, value) {
560 match (value, opt_type_desc) {
561 (Some(..), None) => {
562 early_error(format!("codegen option `{}` takes no \
565 (None, Some(type_desc)) => {
566 early_error(format!("codegen option `{0}` requires \
567 {1} (-C {0}=<value>)",
570 (Some(value), Some(type_desc)) => {
571 early_error(format!("incorrect value `{}` for codegen \
572 option `{}` - {} was expected",
573 value, key, type_desc)[])
575 (None, None) => unreachable!()
582 early_error(format!("unknown codegen option: `{}`",
589 pub fn default_lib_output() -> CrateType {
593 pub fn default_configuration(sess: &Session) -> ast::CrateConfig {
594 use syntax::parse::token::intern_and_get_ident as intern;
596 let end = sess.target.target.target_endian[];
597 let arch = sess.target.target.arch[];
598 let wordsz = sess.target.target.target_word_size[];
599 let os = sess.target.target.target_os[];
601 let fam = match sess.target.target.options.is_like_windows {
602 true => InternedString::new("windows"),
603 false => InternedString::new("unix")
606 let mk = attr::mk_name_value_item_str;
607 return vec!(// Target bindings.
608 attr::mk_word_item(fam.clone()),
609 mk(InternedString::new("target_os"), intern(os)),
610 mk(InternedString::new("target_family"), fam),
611 mk(InternedString::new("target_arch"), intern(arch)),
612 mk(InternedString::new("target_endian"), intern(end)),
613 mk(InternedString::new("target_word_size"),
618 pub fn append_configuration(cfg: &mut ast::CrateConfig,
619 name: InternedString) {
620 if !cfg.iter().any(|mi| mi.name() == name) {
621 cfg.push(attr::mk_word_item(name))
625 pub fn build_configuration(sess: &Session) -> ast::CrateConfig {
626 // Combine the configuration requested by the session (command line) with
627 // some default and generated configuration items
628 let default_cfg = default_configuration(sess);
629 let mut user_cfg = sess.opts.cfg.clone();
630 // If the user wants a test runner, then add the test cfg
632 append_configuration(&mut user_cfg, InternedString::new("test"))
634 let mut v = user_cfg.into_iter().collect::<Vec<_>>();
635 v.push_all(default_cfg[]);
639 pub fn build_target_config(opts: &Options, sp: &SpanHandler) -> Config {
640 let target = match Target::search(opts.target_triple[]) {
643 sp.handler().fatal((format!("Error loading target specification: {}", e))[]);
647 let (int_type, uint_type) = match target.target_word_size[] {
648 "32" => (ast::TyI32, ast::TyU32),
649 "64" => (ast::TyI64, ast::TyU64),
650 w => sp.handler().fatal((format!("target specification was invalid: unrecognized \
651 target-word-size {}", w))[])
657 uint_type: uint_type,
661 /// Returns the "short" subset of the stable rustc command line options.
662 pub fn short_optgroups() -> Vec<getopts::OptGroup> {
663 rustc_short_optgroups().into_iter()
664 .filter(|g|g.is_stable())
669 /// Returns all of the stable rustc command line options.
670 pub fn optgroups() -> Vec<getopts::OptGroup> {
671 rustc_optgroups().into_iter()
672 .filter(|g|g.is_stable())
677 #[deriving(Copy, Clone, PartialEq, Eq, Show)]
678 pub enum OptionStability { Stable, Unstable }
680 #[deriving(Clone, PartialEq, Eq)]
681 pub struct RustcOptGroup {
682 pub opt_group: getopts::OptGroup,
683 pub stability: OptionStability,
687 pub fn is_stable(&self) -> bool {
688 self.stability == OptionStability::Stable
691 fn stable(g: getopts::OptGroup) -> RustcOptGroup {
692 RustcOptGroup { opt_group: g, stability: OptionStability::Stable }
695 fn unstable(g: getopts::OptGroup) -> RustcOptGroup {
696 RustcOptGroup { opt_group: g, stability: OptionStability::Unstable }
700 // The `opt` local module holds wrappers around the `getopts` API that
701 // adds extra rustc-specific metadata to each option; such metadata
702 // is exposed by . The public
703 // functions below ending with `_u` are the functions that return
704 // *unstable* options, i.e. options that are only enabled when the
705 // user also passes the `-Z unstable-options` debugging flag.
707 // The `fn opt_u` etc below are written so that we can use them
708 // in the future; do not warn about them not being used right now.
712 use super::RustcOptGroup;
714 type R = RustcOptGroup;
715 type S<'a> = &'a str;
717 fn stable(g: getopts::OptGroup) -> R { RustcOptGroup::stable(g) }
718 fn unstable(g: getopts::OptGroup) -> R { RustcOptGroup::unstable(g) }
720 // FIXME (pnkfelix): We default to stable since the current set of
721 // options is defacto stable. However, it would be good to revise the
722 // code so that a stable option is the thing that takes extra effort
725 pub fn opt(a: S, b: S, c: S, d: S) -> R { stable(getopts::optopt(a, b, c, d)) }
726 pub fn multi(a: S, b: S, c: S, d: S) -> R { stable(getopts::optmulti(a, b, c, d)) }
727 pub fn flag(a: S, b: S, c: S) -> R { stable(getopts::optflag(a, b, c)) }
728 pub fn flagopt(a: S, b: S, c: S, d: S) -> R { stable(getopts::optflagopt(a, b, c, d)) }
730 pub fn opt_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optopt(a, b, c, d)) }
731 pub fn multi_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optmulti(a, b, c, d)) }
732 pub fn flag_u(a: S, b: S, c: S) -> R { unstable(getopts::optflag(a, b, c)) }
733 pub fn flagopt_u(a: S, b: S, c: S, d: S) -> R { unstable(getopts::optflagopt(a, b, c, d)) }
736 /// Returns the "short" subset of the rustc command line options,
737 /// including metadata for each option, such as whether the option is
738 /// part of the stable long-term interface for rustc.
739 pub fn rustc_short_optgroups() -> Vec<RustcOptGroup> {
741 opt::flag("h", "help", "Display this message"),
742 opt::multi("", "cfg", "Configure the compilation environment", "SPEC"),
743 opt::multi("L", "", "Add a directory to the library search path", "PATH"),
744 opt::multi("l", "", "Link the generated crate(s) to the specified native
745 library NAME. The optional KIND can be one of,
746 static, dylib, or framework. If omitted, dylib is
747 assumed.", "NAME[:KIND]"),
748 opt::multi("", "crate-type", "Comma separated list of types of crates
749 for the compiler to emit",
750 "[bin|lib|rlib|dylib|staticlib]"),
751 opt::opt("", "crate-name", "Specify the name of the crate being built",
753 opt::multi("", "emit", "Comma separated list of types of output for \
754 the compiler to emit",
755 "[asm|llvm-bc|llvm-ir|obj|link|dep-info]"),
756 opt::multi("", "print", "Comma separated list of compiler information to \
758 "[crate-name|output-file-names|sysroot]"),
759 opt::flag("g", "", "Equivalent to -C debuginfo=2"),
760 opt::flag("O", "", "Equivalent to -C opt-level=2"),
761 opt::opt("o", "", "Write output to <filename>", "FILENAME"),
762 opt::opt("", "out-dir", "Write output to compiler-chosen filename \
764 opt::opt("", "explain", "Provide a detailed explanation of an error \
766 opt::flag("", "test", "Build a test harness"),
767 opt::opt("", "target", "Target triple cpu-manufacturer-kernel[-os] \
768 to compile for (see chapter 3.4 of \
769 http://www.sourceware.org/autobook/
772 opt::multi("W", "warn", "Set lint warnings", "OPT"),
773 opt::multi("A", "allow", "Set lint allowed", "OPT"),
774 opt::multi("D", "deny", "Set lint denied", "OPT"),
775 opt::multi("F", "forbid", "Set lint forbidden", "OPT"),
776 opt::multi("C", "codegen", "Set a codegen option", "OPT[=VALUE]"),
777 opt::flag("V", "version", "Print version info and exit"),
778 opt::flag("v", "verbose", "Use verbose output"),
782 /// Returns all rustc command line options, including metadata for
783 /// each option, such as whether the option is part of the stable
784 /// long-term interface for rustc.
785 pub fn rustc_optgroups() -> Vec<RustcOptGroup> {
786 let mut opts = rustc_short_optgroups();
788 opt::multi("", "extern", "Specify where an external rust library is \
791 opt::opt("", "opt-level", "Optimize with possible levels 0-3", "LEVEL"),
792 opt::opt("", "sysroot", "Override the system root", "PATH"),
793 opt::multi("Z", "", "Set internal debugging options", "FLAG"),
794 opt::opt("", "color", "Configure coloring of output:
795 auto = colorize, if output goes to a tty (default);
796 always = always colorize output;
797 never = never colorize output", "auto|always|never"),
800 opt::flag("", "print-crate-name", "Output the crate name and exit"),
801 opt::flag("", "print-file-name", "Output the file(s) that would be \
802 written if compilation \
803 continued and exit"),
804 opt::opt("", "debuginfo", "Emit DWARF debug info to the objects created:
806 1 = line-tables only (for stacktraces and breakpoints),
807 2 = full debug info with variable and type information \
808 (same as -g)", "LEVEL"),
809 opt::flag("", "no-trans", "Run all passes except translation; no output"),
810 opt::flag("", "no-analysis", "Parse and expand the source, but run no \
811 analysis and produce no output"),
812 opt::flag("", "parse-only", "Parse only; do not compile, assemble, \
814 opt::flagopt("", "pretty",
815 "Pretty-print the input instead of compiling;
816 valid types are: `normal` (un-annotated source),
817 `expanded` (crates expanded),
818 `typed` (crates expanded, with type annotations), or
819 `expanded,identified` (fully parenthesized, AST nodes with IDs).",
821 opt::flagopt_u("", "xpretty",
822 "Pretty-print the input instead of compiling, unstable variants;
823 valid types are any of the types for `--pretty`, as well as:
824 `flowgraph=<nodeid>` (graphviz formatted flowgraph for node), or
825 `everybody_loops` (all function bodies replaced with `loop {}`).",
827 opt::flagopt("", "dep-info",
828 "Output dependency info to <filename> after compiling, \
829 in a format suitable for use by Makefiles", "FILENAME"),
834 // Convert strings provided as --cfg [cfgspec] into a crate_cfg
835 pub fn parse_cfgspecs(cfgspecs: Vec<String> ) -> ast::CrateConfig {
836 cfgspecs.into_iter().map(|s| {
837 parse::parse_meta_from_source_str("cfgspec".to_string(),
840 &parse::new_parse_sess())
841 }).collect::<ast::CrateConfig>()
844 pub fn build_session_options(matches: &getopts::Matches) -> Options {
846 let unparsed_crate_types = matches.opt_strs("crate-type");
847 let crate_types = parse_crate_types_from_list(unparsed_crate_types)
848 .unwrap_or_else(|e| early_error(e[]));
850 let mut lint_opts = vec!();
851 let mut describe_lints = false;
853 for &level in [lint::Allow, lint::Warn, lint::Deny, lint::Forbid].iter() {
854 for lint_name in matches.opt_strs(level.as_str()).into_iter() {
855 if lint_name == "help" {
856 describe_lints = true;
858 lint_opts.push((lint_name.replace("-", "_"), level));
863 let mut debugging_opts = 0;
864 let debug_flags = matches.opt_strs("Z");
865 let debug_map = debugging_opts_map();
866 for debug_flag in debug_flags.iter() {
867 let mut this_bit = 0;
868 for &(name, _, bit) in debug_map.iter() {
869 if name == *debug_flag {
875 early_error(format!("unknown debug flag: {}",
878 debugging_opts |= this_bit;
881 let parse_only = if matches.opt_present("parse-only") {
882 // FIXME(acrichto) uncomment deprecation warning
883 // early_warn("--parse-only is deprecated in favor of -Z parse-only");
886 debugging_opts & PARSE_ONLY != 0
888 let no_trans = if matches.opt_present("no-trans") {
889 // FIXME(acrichto) uncomment deprecation warning
890 // early_warn("--no-trans is deprecated in favor of -Z no-trans");
893 debugging_opts & NO_TRANS != 0
895 let no_analysis = if matches.opt_present("no-analysis") {
896 // FIXME(acrichto) uncomment deprecation warning
897 // early_warn("--no-analysis is deprecated in favor of -Z no-analysis");
900 debugging_opts & NO_ANALYSIS != 0
903 if debugging_opts & DEBUG_LLVM != 0 {
904 unsafe { llvm::LLVMSetDebug(1); }
907 let mut output_types = Vec::new();
908 if !parse_only && !no_trans {
909 let unparsed_output_types = matches.opt_strs("emit");
910 for unparsed_output_type in unparsed_output_types.iter() {
911 for part in unparsed_output_type.split(',') {
912 let output_type = match part.as_slice() {
913 "asm" => OutputTypeAssembly,
914 "llvm-ir" => OutputTypeLlvmAssembly,
915 "llvm-bc" => OutputTypeBitcode,
916 "obj" => OutputTypeObject,
917 "link" => OutputTypeExe,
918 "dep-info" => OutputTypeDepInfo,
920 early_error(format!("unknown emission type: `{}`",
924 output_types.push(output_type)
929 output_types.dedup();
930 if output_types.len() == 0 {
931 output_types.push(OutputTypeExe);
934 let cg = build_codegen_options(matches);
936 let sysroot_opt = matches.opt_str("sysroot").map(|m| Path::new(m));
937 let target = matches.opt_str("target").unwrap_or(
938 host_triple().to_string());
940 if matches.opt_present("O") {
941 if matches.opt_present("opt-level") {
942 early_error("-O and --opt-level both provided");
944 if cg.opt_level.is_some() {
945 early_error("-O and -C opt-level both provided");
948 } else if matches.opt_present("opt-level") {
949 // FIXME(acrichto) uncomment deprecation warning
950 // early_warn("--opt-level=N is deprecated in favor of -C opt-level=N");
951 match matches.opt_str("opt-level").as_ref().map(|s| s.as_slice()) {
955 Some("2") => Default,
956 Some("3") => Aggressive,
958 early_error(format!("optimization level needs to be \
959 between 0-3 (instead was `{}`)",
969 Some(3) => Aggressive,
971 early_error(format!("optimization level needs to be \
972 between 0-3 (instead was `{}`)",
978 let gc = debugging_opts & GC != 0;
979 let debuginfo = if matches.opt_present("g") {
980 if matches.opt_present("debuginfo") {
981 early_error("-g and --debuginfo both provided");
983 if cg.debuginfo.is_some() {
984 early_error("-g and -C debuginfo both provided");
987 } else if matches.opt_present("debuginfo") {
988 // FIXME(acrichto) uncomment deprecation warning
989 // early_warn("--debuginfo=N is deprecated in favor of -C debuginfo=N");
990 match matches.opt_str("debuginfo").as_ref().map(|s| s.as_slice()) {
991 Some("0") => NoDebugInfo,
992 Some("1") => LimitedDebugInfo,
994 Some("2") => FullDebugInfo,
996 early_error(format!("debug info level needs to be between \
997 0-2 (instead was `{}`)",
1002 match cg.debuginfo {
1003 None | Some(0) => NoDebugInfo,
1004 Some(1) => LimitedDebugInfo,
1005 Some(2) => FullDebugInfo,
1007 early_error(format!("debug info level needs to be between \
1008 0-2 (instead was `{}`)",
1014 let mut search_paths = SearchPaths::new();
1015 for s in matches.opt_strs("L").iter() {
1016 search_paths.add_path(s[]);
1019 let libs = matches.opt_strs("l").into_iter().map(|s| {
1020 let mut parts = s.rsplitn(1, ':');
1021 let kind = parts.next().unwrap();
1022 let (name, kind) = match (parts.next(), kind) {
1024 (Some(name), "dylib") => (name, cstore::NativeUnknown),
1025 (Some(name), "framework") => (name, cstore::NativeFramework),
1026 (Some(name), "static") => (name, cstore::NativeStatic),
1028 early_error(format!("unknown library kind `{}`, expected \
1029 one of dylib, framework, or static",
1033 (name.to_string(), kind)
1036 let cfg = parse_cfgspecs(matches.opt_strs("cfg"));
1037 let test = matches.opt_present("test");
1038 let write_dependency_info = if matches.opt_present("dep-info") {
1039 // FIXME(acrichto) uncomment deprecation warning
1040 // early_warn("--dep-info has been deprecated in favor of --emit");
1041 (true, matches.opt_str("dep-info").map(|p| Path::new(p)))
1043 (output_types.contains(&OutputTypeDepInfo), None)
1046 let mut prints = matches.opt_strs("print").into_iter().map(|s| {
1047 match s.as_slice() {
1048 "crate-name" => PrintRequest::CrateName,
1049 "file-names" => PrintRequest::FileNames,
1050 "sysroot" => PrintRequest::Sysroot,
1052 early_error(format!("unknown print request `{}`", req).as_slice())
1055 }).collect::<Vec<_>>();
1056 if matches.opt_present("print-crate-name") {
1057 // FIXME(acrichto) uncomment deprecation warning
1058 // early_warn("--print-crate-name has been deprecated in favor of \
1059 // --print crate-name");
1060 prints.push(PrintRequest::CrateName);
1062 if matches.opt_present("print-file-name") {
1063 // FIXME(acrichto) uncomment deprecation warning
1064 // early_warn("--print-file-name has been deprecated in favor of \
1065 // --print file-names");
1066 prints.push(PrintRequest::FileNames);
1069 if !cg.remark.is_empty() && debuginfo == NoDebugInfo {
1070 // FIXME(acrichto) uncomment deprecation warning
1071 // early_warn("-C remark will not show source locations without \
1075 let color = match matches.opt_str("color").as_ref().map(|s| s[]) {
1076 Some("auto") => Auto,
1077 Some("always") => Always,
1078 Some("never") => Never,
1083 early_error(format!("argument for --color must be auto, always \
1084 or never (instead was `{}`)",
1089 let mut externs = HashMap::new();
1090 for arg in matches.opt_strs("extern").iter() {
1091 let mut parts = arg.splitn(1, '=');
1092 let name = match parts.next() {
1094 None => early_error("--extern value must not be empty"),
1096 let location = match parts.next() {
1098 None => early_error("--extern value must be of the format `foo=bar`"),
1101 match externs.entry(name.to_string()) {
1102 Vacant(entry) => { entry.set(vec![location.to_string()]); },
1103 Occupied(mut entry) => { entry.get_mut().push(location.to_string()); },
1107 let crate_name = matches.opt_str("crate-name");
1110 crate_types: crate_types,
1112 optimize: opt_level,
1113 debuginfo: debuginfo,
1114 lint_opts: lint_opts,
1115 describe_lints: describe_lints,
1116 output_types: output_types,
1117 search_paths: search_paths,
1118 maybe_sysroot: sysroot_opt,
1119 target_triple: target,
1122 parse_only: parse_only,
1124 no_analysis: no_analysis,
1125 debugging_opts: debugging_opts,
1126 write_dependency_info: write_dependency_info,
1131 crate_name: crate_name,
1137 pub fn parse_crate_types_from_list(list_list: Vec<String>) -> Result<Vec<CrateType>, String> {
1139 let mut crate_types: Vec<CrateType> = Vec::new();
1140 for unparsed_crate_type in list_list.iter() {
1141 for part in unparsed_crate_type.split(',') {
1142 let new_part = match part {
1143 "lib" => default_lib_output(),
1144 "rlib" => CrateTypeRlib,
1145 "staticlib" => CrateTypeStaticlib,
1146 "dylib" => CrateTypeDylib,
1147 "bin" => CrateTypeExecutable,
1149 return Err(format!("unknown crate type: `{}`",
1153 crate_types.push(new_part)
1157 return Ok(crate_types);
1160 impl fmt::Show for CrateType {
1161 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1163 CrateTypeExecutable => "bin".fmt(f),
1164 CrateTypeDylib => "dylib".fmt(f),
1165 CrateTypeRlib => "rlib".fmt(f),
1166 CrateTypeStaticlib => "staticlib".fmt(f)
1174 use session::config::{build_configuration, optgroups, build_session_options};
1175 use session::build_session;
1177 use getopts::getopts;
1179 use syntax::attr::AttrMetaMethods;
1180 use syntax::diagnostics;
1182 // When the user supplies --test we should implicitly supply --cfg test
1184 fn test_switch_implies_cfg_test() {
1186 &match getopts(&["--test".to_string()], optgroups()[]) {
1188 Err(f) => panic!("test_switch_implies_cfg_test: {}", f)
1190 let registry = diagnostics::registry::Registry::new(&[]);
1191 let sessopts = build_session_options(matches);
1192 let sess = build_session(sessopts, None, registry);
1193 let cfg = build_configuration(&sess);
1194 assert!((attr::contains_name(cfg[], "test")));
1197 // When the user supplies --test and --cfg test, don't implicitly add
1198 // another --cfg test
1200 fn test_switch_implies_cfg_test_unless_cfg_test() {
1202 &match getopts(&["--test".to_string(), "--cfg=test".to_string()],
1206 panic!("test_switch_implies_cfg_test_unless_cfg_test: {}", f)
1209 let registry = diagnostics::registry::Registry::new(&[]);
1210 let sessopts = build_session_options(matches);
1211 let sess = build_session(sessopts, None, registry);
1212 let cfg = build_configuration(&sess);
1213 let mut test_items = cfg.iter().filter(|m| m.name() == "test");
1214 assert!(test_items.next().is_some());
1215 assert!(test_items.next().is_none());
1219 fn test_can_print_warnings() {
1221 let matches = getopts(&[
1222 "-Awarnings".to_string()
1223 ], optgroups()[]).unwrap();
1224 let registry = diagnostics::registry::Registry::new(&[]);
1225 let sessopts = build_session_options(&matches);
1226 let sess = build_session(sessopts, None, registry);
1227 assert!(!sess.can_print_warnings);
1231 let matches = getopts(&[
1232 "-Awarnings".to_string(),
1233 "-Dwarnings".to_string()
1234 ], optgroups()[]).unwrap();
1235 let registry = diagnostics::registry::Registry::new(&[]);
1236 let sessopts = build_session_options(&matches);
1237 let sess = build_session(sessopts, None, registry);
1238 assert!(sess.can_print_warnings);
1242 let matches = getopts(&[
1243 "-Adead_code".to_string()
1244 ], optgroups()[]).unwrap();
1245 let registry = diagnostics::registry::Registry::new(&[]);
1246 let sessopts = build_session_options(&matches);
1247 let sess = build_session(sessopts, None, registry);
1248 assert!(sess.can_print_warnings);