diff --git a/Makefile.in b/Makefile.in index 629b4426c2c..48e26e804c7 100644 --- a/Makefile.in +++ b/Makefile.in @@ -209,8 +209,11 @@ STDLIB_INPUTS := $(wildcard $(addprefix $(S)src/libstd/, \ ###################################################################### COMPILER_CRATE := $(S)src/comp/rustc.rc -COMPILER_INPUTS := $(wildcard $(addprefix $(S)src/comp/, \ - rustc.rc *.rs */*.rs */*/*.rs)) +COMPILER_INPUTS := $(filter-out $(S)src/comp/driver/rustc.rs, \ + $(wildcard $(addprefix $(S)src/comp/, \ + rustc.rc *.rs */*.rs */*/*.rs))) + +RUSTC_INPUTS := $(S)src/comp/driver/rustc.rs ###################################################################### # LLVM macros diff --git a/mk/perf.mk b/mk/perf.mk index 56c9c0de178..a67cf453e2a 100644 --- a/mk/perf.mk +++ b/mk/perf.mk @@ -2,8 +2,9 @@ ifdef CFG_PERF_TOOL rustc-perf$(X): $(CFG_HOST_TRIPLE)/stage2/bin/rustc$(X) @$(call E, perf compile: $@) - $(PERF_STAGE2_T_$(CFG_HOST_TRIPLE)_H_$(CFG_HOST_TRIPLE)) -o $@ $(COMPILER_CRATE) >rustc-perf.err 2>&1 - $(Q)rm -f $@ + $(PERF_STAGE2_T_$(CFG_HOST_TRIPLE)_H_$(CFG_HOST_TRIPLE)) --lib \ + -o $@ $(COMPILER_CRATE) >rustc-perf.err 2>&1 + $(Q)rm -f $(LIBRUSTC_GLOB) else rustc-perf$(X): $(CFG_HOST_TRIPLE)/stage2/bin/rustc$(X) $(Q)touch $@ diff --git a/mk/target.mk b/mk/target.mk index 5d77a3697e2..2ac8fe73ad3 100644 --- a/mk/target.mk +++ b/mk/target.mk @@ -46,17 +46,14 @@ $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM): \ $$(Q)cp $$< $$@ $$(TBIN$(1)_T_$(2)_H_$(3))/rustc$$(X): \ - $$(COMPILER_CRATE) $$(COMPILER_INPUTS) \ - $$(TSREQ$(1)_T_$(2)_H_$(3)) \ - $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM) \ - $$(TCORELIB_DEFAULT$(1)_T_$(2)_H_$(3)) \ - $$(TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3)) + $$(RUSTC_INPUTS) \ + $$(TLIBRUSTC_DEFAULT$(1)_T_$(2)_H_$(3)) @$$(call E, compile_and_link: $$@) $$(STAGE$(1)_T_$(2)_H_$(3)) -o $$@ $$< $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_LIBRUSTC): \ $$(COMPILER_CRATE) $$(COMPILER_INPUTS) \ - $$(TSREQ$(1)_T_$(2)_H_$(3)) \ + $$(TSREQ$(1)_T_$(2)_H_$(3)) \ $$(TLIB$(1)_T_$(2)_H_$(3))/$$(CFG_RUSTLLVM) \ $$(TCORELIB_DEFAULT$(1)_T_$(2)_H_$(3)) \ $$(TSTDLIB_DEFAULT$(1)_T_$(2)_H_$(3)) diff --git a/src/comp/driver/driver.rs b/src/comp/driver/driver.rs new file mode 100644 index 00000000000..1958025b6cb --- /dev/null +++ b/src/comp/driver/driver.rs @@ -0,0 +1,615 @@ + + +// -*- rust -*- +import metadata::{creader, cstore}; +import syntax::parse::{parser}; +import syntax::{ast, codemap}; +import front::attr; +import middle::{trans, resolve, freevars, kind, ty, typeck, fn_usage, + last_use}; +import syntax::print::{pp, pprust}; +import util::{ppaux, filesearch}; +import back::link; +import core::{option, str, int, result}; +import result::{ok, err}; +import std::{fs, io, getopts}; +import option::{some, none}; +import getopts::{optopt, optmulti, optflag, optflagopt, opt_present}; +import back::{x86, x86_64}; + +tag pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; } + +fn default_configuration(sess: session::session, argv0: str, input: str) -> + ast::crate_cfg { + let libc = + alt sess.get_targ_cfg().os { + session::os_win32. { "msvcrt.dll" } + session::os_macos. { "libc.dylib" } + session::os_linux. { "libc.so.6" } + _ { "libc.so" } + }; + + let mk = attr::mk_name_value_item_str; + + let arch = alt sess.get_targ_cfg().arch { + session::arch_x86. { "x86" } + session::arch_x86_64. { "x86_64" } + session::arch_arm. { "arm" } + }; + + ret [ // Target bindings. + mk("target_os", std::os::target_os()), + mk("target_arch", arch), + mk("target_libc", libc), + // Build bindings. + mk("build_compiler", argv0), + mk("build_input", input)]; +} + +fn build_configuration(sess: session::session, argv0: str, input: str) -> + ast::crate_cfg { + // Combine the configuration requested by the session (command line) with + // some default and generated configuration items + let default_cfg = default_configuration(sess, argv0, input); + let user_cfg = sess.get_opts().cfg; + // If the user wants a test runner, then add the test cfg + let gen_cfg = + { + if sess.get_opts().test && !attr::contains_name(user_cfg, "test") + { + [attr::mk_word_item("test")] + } else { [] } + }; + ret user_cfg + gen_cfg + default_cfg; +} + +// Convert strings provided as --cfg [cfgspec] into a crate_cfg +fn parse_cfgspecs(cfgspecs: [str]) -> ast::crate_cfg { + // FIXME: It would be nice to use the parser to parse all varieties of + // meta_item here. At the moment we just support the meta_word variant. + let words = []; + for s: str in cfgspecs { words += [attr::mk_word_item(s)]; } + ret words; +} + +fn input_is_stdin(filename: str) -> bool { filename == "-" } + +fn parse_input(sess: session::session, cfg: ast::crate_cfg, input: str) -> + @ast::crate { + if !input_is_stdin(input) { + parser::parse_crate_from_file(input, cfg, sess.get_parse_sess()) + } else { parse_input_src(sess, cfg, input).crate } +} + +fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str) + -> {crate: @ast::crate, src: str} { + let srcbytes = if infile != "-" { + alt io::file_reader(infile) { + result::ok(reader) { reader } + result::err(e) { + sess.fatal(e) + } + } + } else { + io::stdin() + }.read_whole_stream(); + let src = str::unsafe_from_bytes(srcbytes); + let crate = + parser::parse_crate_from_source_str(infile, src, cfg, + sess.get_parse_sess()); + ret {crate: crate, src: src}; +} + +fn time(do_it: bool, what: str, thunk: fn@() -> T) -> T { + if !do_it { ret thunk(); } + let start = std::time::precise_time_s(); + let rv = thunk(); + let end = std::time::precise_time_s(); + log_err #fmt["time: %s took %s s", what, + float::to_str(end - start, 3u)]; + ret rv; +} + +fn inject_libcore_reference(sess: session::session, + crate: @ast::crate) -> @ast::crate { + + fn spanned(x: T) -> @ast::spanned { + ret @{node: x, + span: {lo: 0u, hi: 0u, + expanded_from: codemap::os_none}}; + } + + let n1 = sess.next_node_id(); + let n2 = sess.next_node_id(); + + let vi1 = spanned(ast::view_item_use("core", [], n1)); + let vi2 = spanned(ast::view_item_import_glob(@["core"], n2)); + + let vis = [vi1, vi2] + crate.node.module.view_items; + + ret @{node: {module: { view_items: vis with crate.node.module } + with crate.node} with *crate } +} + + +fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str, + outdir: option::t, output: option::t) { + + let time_passes = sess.get_opts().time_passes; + let crate = + time(time_passes, "parsing", bind parse_input(sess, cfg, input)); + if sess.get_opts().parse_only { ret; } + + sess.set_building_library(crate); + + crate = + time(time_passes, "configuration", + bind front::config::strip_unconfigured_items(crate)); + if sess.get_opts().test { + crate = + time(time_passes, "building test harness", + bind front::test::modify_for_testing(sess, crate)); + } + crate = + time(time_passes, "expansion", + bind syntax::ext::expand::expand_crate(sess, crate)); + + if sess.get_opts().libcore { + crate = inject_libcore_reference(sess, crate); + } + + let ast_map = + time(time_passes, "ast indexing", + bind middle::ast_map::map_crate(*crate)); + time(time_passes, "external crate/lib resolution", + bind creader::read_crates(sess, *crate)); + let {def_map, exp_map, impl_map} = + time(time_passes, "resolution", + bind resolve::resolve_crate(sess, ast_map, crate)); + let freevars = + time(time_passes, "freevar finding", + bind freevars::annotate_freevars(def_map, crate)); + time(time_passes, "const checking", + bind middle::check_const::check_crate(sess, crate)); + let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars); + let method_map = time(time_passes, "typechecking", + bind typeck::check_crate(ty_cx, impl_map, crate)); + time(time_passes, "block-use checking", + bind middle::block_use::check_crate(ty_cx, crate)); + time(time_passes, "function usage", + bind fn_usage::check_crate_fn_usage(ty_cx, crate)); + time(time_passes, "alt checking", + bind middle::check_alt::check_crate(ty_cx, crate)); + time(time_passes, "typestate checking", + bind middle::tstate::ck::check_crate(ty_cx, crate)); + let mut_map = + time(time_passes, "mutability checking", + bind middle::mut::check_crate(ty_cx, crate)); + let (copy_map, ref_map) = + time(time_passes, "alias checking", + bind middle::alias::check_crate(ty_cx, crate)); + let last_uses = time(time_passes, "last use finding", + bind last_use::find_last_uses(crate, def_map, ref_map, ty_cx)); + time(time_passes, "kind checking", + bind kind::check_crate(ty_cx, method_map, last_uses, crate)); + if sess.get_opts().no_trans { ret; } + + let outputs = build_output_filenames(input, outdir, output, sess); + + let (llmod, link_meta) = + time(time_passes, "translation", + bind trans::trans_crate(sess, crate, ty_cx, + outputs.obj_filename, exp_map, ast_map, + mut_map, copy_map, last_uses, + method_map)); + time(time_passes, "LLVM passes", + bind link::write::run_passes(sess, llmod, outputs.obj_filename)); + + let stop_after_codegen = + sess.get_opts().output_type != link::output_type_exe || + sess.get_opts().static && sess.building_library(); + + if stop_after_codegen { ret; } + + time(time_passes, "Linking", + bind link::link_binary(sess, outputs.obj_filename, + outputs.out_filename, link_meta)); +} + +fn pretty_print_input(sess: session::session, cfg: ast::crate_cfg, input: str, + ppm: pp_mode) { + fn ann_paren_for_expr(node: pprust::ann_node) { + alt node { pprust::node_expr(s, expr) { pprust::popen(s); } _ { } } + } + fn ann_typed_post(tcx: ty::ctxt, node: pprust::ann_node) { + alt node { + pprust::node_expr(s, expr) { + pp::space(s.s); + pp::word(s.s, "as"); + pp::space(s.s); + pp::word(s.s, ppaux::ty_to_str(tcx, ty::expr_ty(tcx, expr))); + pprust::pclose(s); + } + _ { } + } + } + fn ann_identified_post(node: pprust::ann_node) { + alt node { + pprust::node_item(s, item) { + pp::space(s.s); + pprust::synth_comment(s, int::to_str(item.id, 10u)); + } + pprust::node_block(s, blk) { + pp::space(s.s); + pprust::synth_comment(s, + "block " + int::to_str(blk.node.id, 10u)); + } + pprust::node_expr(s, expr) { + pp::space(s.s); + pprust::synth_comment(s, int::to_str(expr.id, 10u)); + pprust::pclose(s); + } + _ { } + } + } + + // Because the pretty printer needs to make a pass over the source + // to collect comments and literals, and we need to support reading + // from stdin, we're going to just suck the source into a string + // so both the parser and pretty-printer can use it. + let crate_src = parse_input_src(sess, cfg, input); + let crate = crate_src.crate; + let src = crate_src.src; + + let ann; + alt ppm { + ppm_expanded. { + crate = syntax::ext::expand::expand_crate(sess, crate); + ann = pprust::no_ann(); + } + ppm_typed. { + crate = syntax::ext::expand::expand_crate(sess, crate); + let amap = middle::ast_map::map_crate(*crate); + let {def_map, impl_map, _} = + resolve::resolve_crate(sess, amap, crate); + let freevars = freevars::annotate_freevars(def_map, crate); + let ty_cx = ty::mk_ctxt(sess, def_map, amap, freevars); + typeck::check_crate(ty_cx, impl_map, crate); + ann = {pre: ann_paren_for_expr, post: bind ann_typed_post(ty_cx, _)}; + } + ppm_identified. { + ann = {pre: ann_paren_for_expr, post: ann_identified_post}; + } + ppm_normal. { ann = pprust::no_ann(); } + } + pprust::print_crate(sess.get_codemap(), crate, input, + io::string_reader(src), io::stdout(), ann); +} + +fn get_os(triple: str) -> session::os { + ret if str::find(triple, "win32") >= 0 || + str::find(triple, "mingw32") >= 0 { + session::os_win32 + } else if str::find(triple, "darwin") >= 0 { + session::os_macos + } else if str::find(triple, "linux") >= 0 { + session::os_linux + } else { early_error("Unknown operating system!") }; +} + +fn get_arch(triple: str) -> session::arch { + ret if str::find(triple, "i386") >= 0 || str::find(triple, "i486") >= 0 || + str::find(triple, "i586") >= 0 || + str::find(triple, "i686") >= 0 || + str::find(triple, "i786") >= 0 { + session::arch_x86 + } else if str::find(triple, "x86_64") >= 0 { + session::arch_x86_64 + } else if str::find(triple, "arm") >= 0 || + str::find(triple, "xscale") >= 0 { + session::arch_arm + } else { early_error("Unknown architecture! " + triple) }; +} + +fn build_target_config(sopts: @session::options) -> @session::config { + let os = get_os(sopts.target_triple); + let arch = get_arch(sopts.target_triple); + let (int_type, uint_type, float_type) = alt arch { + session::arch_x86. {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} + session::arch_x86_64. {(ast::ty_i64, ast::ty_u64, ast::ty_f64)} + session::arch_arm. {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} + }; + let target_strs = alt arch { + session::arch_x86. {x86::get_target_strs(os)} + session::arch_x86_64. {x86_64::get_target_strs(os)} + session::arch_arm. {x86::get_target_strs(os)} + }; + let target_cfg: @session::config = + @{os: os, arch: arch, target_strs: target_strs, int_type: int_type, + uint_type: uint_type, float_type: float_type}; + ret target_cfg; +} + +fn host_triple() -> str { + // Get the host triple out of the build environment. This ensures that our + // idea of the host triple is the same as for the set of libraries we've + // actually built. We can't just take LLVM's host triple because they + // normalize all ix86 architectures to i386. + // FIXME: Instead of grabbing the host triple we really should be + // grabbing (at compile time) the target triple that this rustc is + // built with and calling that (at runtime) the host triple. + let ht = #env("CFG_HOST_TRIPLE"); + ret ht != "" ? ht : fail "rustc built without CFG_HOST_TRIPLE"; +} + +fn build_session_options(match: getopts::match) + -> @session::options { + let crate_type = if opt_present(match, "lib") { + session::lib_crate + } else if opt_present(match, "bin") { + session::bin_crate + } else { + session::unknown_crate + }; + let static = opt_present(match, "static"); + + let parse_only = opt_present(match, "parse-only"); + let no_trans = opt_present(match, "no-trans"); + + let output_type = + if parse_only || no_trans { + link::output_type_none + } else if opt_present(match, "S") && opt_present(match, "emit-llvm") { + link::output_type_llvm_assembly + } else if opt_present(match, "S") { + link::output_type_assembly + } else if opt_present(match, "c") { + link::output_type_object + } else if opt_present(match, "emit-llvm") { + link::output_type_bitcode + } else { link::output_type_exe }; + let libcore = !opt_present(match, "no-core"); + let verify = !opt_present(match, "no-verify"); + let save_temps = opt_present(match, "save-temps"); + let extra_debuginfo = opt_present(match, "xg"); + let debuginfo = opt_present(match, "g") || extra_debuginfo; + let stats = opt_present(match, "stats"); + let time_passes = opt_present(match, "time-passes"); + let time_llvm_passes = opt_present(match, "time-llvm-passes"); + let sysroot_opt = getopts::opt_maybe_str(match, "sysroot"); + let target_opt = getopts::opt_maybe_str(match, "target"); + let no_asm_comments = getopts::opt_present(match, "no-asm-comments"); + alt output_type { + // unless we're emitting huamn-readable assembly, omit comments. + link::output_type_llvm_assembly. | link::output_type_assembly. {} + _ { no_asm_comments = true; } + } + let opt_level: uint = + if opt_present(match, "O") { + if opt_present(match, "opt-level") { + early_error("-O and --opt-level both provided"); + } + 2u + } else if opt_present(match, "opt-level") { + alt getopts::opt_str(match, "opt-level") { + "0" { 0u } + "1" { 1u } + "2" { 2u } + "3" { 3u } + _ { + early_error("optimization level needs " + + "to be between 0-3") + } + } + } else { 0u }; + let target = + alt target_opt { + none. { host_triple() } + some(s) { s } + }; + + let addl_lib_search_paths = getopts::opt_strs(match, "L"); + let cfg = parse_cfgspecs(getopts::opt_strs(match, "cfg")); + let test = opt_present(match, "test"); + let do_gc = opt_present(match, "gc"); + let warn_unused_imports = opt_present(match, "warn-unused-imports"); + let sopts: @session::options = + @{crate_type: crate_type, + static: static, + libcore: libcore, + optimize: opt_level, + debuginfo: debuginfo, + extra_debuginfo: extra_debuginfo, + verify: verify, + save_temps: save_temps, + stats: stats, + time_passes: time_passes, + time_llvm_passes: time_llvm_passes, + output_type: output_type, + addl_lib_search_paths: addl_lib_search_paths, + maybe_sysroot: sysroot_opt, + target_triple: target, + cfg: cfg, + test: test, + parse_only: parse_only, + no_trans: no_trans, + do_gc: do_gc, + no_asm_comments: no_asm_comments, + warn_unused_imports: warn_unused_imports}; + ret sopts; +} + +fn build_session(sopts: @session::options, input: str) -> session::session { + let target_cfg = build_target_config(sopts); + let cstore = cstore::mk_cstore(); + let filesearch = filesearch::mk_filesearch( + sopts.maybe_sysroot, + sopts.target_triple, + sopts.addl_lib_search_paths); + ret session::session(target_cfg, sopts, cstore, + @{cm: codemap::new_codemap(), mutable next_id: 1}, + none, 0u, filesearch, false, fs::dirname(input)); +} + +fn parse_pretty(sess: session::session, &&name: str) -> pp_mode { + if str::eq(name, "normal") { + ret ppm_normal; + } else if str::eq(name, "expanded") { + ret ppm_expanded; + } else if str::eq(name, "typed") { + ret ppm_typed; + } else if str::eq(name, "identified") { ret ppm_identified; } + sess.fatal("argument to `pretty` must be one of `normal`, `typed`, or " + + "`identified`"); +} + +fn opts() -> [getopts::opt] { + ret [optflag("h"), optflag("help"), optflag("v"), optflag("version"), + optflag("emit-llvm"), optflagopt("pretty"), + optflag("ls"), optflag("parse-only"), optflag("no-trans"), + optflag("O"), optopt("opt-level"), optmulti("L"), optflag("S"), + optopt("o"), optopt("out-dir"), optflag("xg"), + optflag("c"), optflag("g"), optflag("save-temps"), + optopt("sysroot"), optopt("target"), optflag("stats"), + optflag("time-passes"), optflag("time-llvm-passes"), + optflag("no-verify"), + optmulti("cfg"), optflag("test"), + optflag("no-core"), + optflag("lib"), optflag("bin"), optflag("static"), optflag("gc"), + optflag("no-asm-comments"), + optflag("warn-unused-imports")]; +} + +fn build_output_filenames(ifile: str, + odir: option::t, + ofile: option::t, + sess: session::session) + -> @{out_filename: str, obj_filename:str} { + let obj_path = ""; + let out_path: str = ""; + let sopts = sess.get_opts(); + let stop_after_codegen = + sopts.output_type != link::output_type_exe || + sopts.static && sess.building_library(); + + + let obj_suffix = + alt sopts.output_type { + link::output_type_none. { "none" } + link::output_type_bitcode. { "bc" } + link::output_type_assembly. { "s" } + link::output_type_llvm_assembly. { "ll" } + // Object and exe output both use the '.o' extension here + link::output_type_object. | link::output_type_exe. { + "o" + } + }; + + alt ofile { + none. { + // "-" as input file will cause the parser to read from stdin so we + // have to make up a name + // We want to toss everything after the final '.' + let dirname = alt odir { + some(d) { d } + none. { + if input_is_stdin(ifile) { + std::os::getcwd() + } else { + fs::dirname(ifile) + } + } + }; + + let (base_path, _) = if !input_is_stdin(ifile) { + fs::splitext(ifile) + } else { + (fs::connect(dirname, "rust_out"), "") + }; + + + if sess.building_library() { + let basename = fs::basename(base_path); + let dylibname = std::os::dylib_filename(basename); + out_path = fs::connect(dirname, dylibname); + obj_path = fs::connect(dirname, basename + "." + obj_path); + } else { + out_path = base_path; + obj_path = base_path + "." + obj_suffix; + } + } + + some(out_file) { + out_path = out_file; + obj_path = if stop_after_codegen { + out_file + } else { + let (base, _) = fs::splitext(out_file); + let modified = base + "." + obj_suffix; + modified + }; + + if sess.building_library() { + // FIXME: We might want to warn here; we're actually not going to + // respect the user's choice of library name when it comes time to + // link, we'll be linking to lib--.so no + // matter what. + } + + if odir != none { + sess.warn("Ignoring --out-dir flag due to -o flag."); + } + } + } + ret @{out_filename: out_path, + obj_filename: obj_path}; +} + +fn early_error(msg: str) -> ! { + codemap::print_diagnostic("", codemap::error, msg); + fail; +} + +fn list_metadata(sess: session::session, path: str, out: io::writer) { + metadata::creader::list_file_metadata(sess, path, out); +} + +#[cfg(test)] +mod test { + + // When the user supplies --test we should implicitly supply --cfg test + #[test] + fn test_switch_implies_cfg_test() { + let match = + alt getopts::getopts(["--test"], opts()) { + ok(m) { m } + }; + let sessopts = build_session_options(match); + let sess = build_session(sessopts, ""); + let cfg = build_configuration(sess, "whatever", "whatever"); + assert (attr::contains_name(cfg, "test")); + } + + // When the user supplies --test and --cfg test, don't implicitly add + // another --cfg test + #[test] + fn test_switch_implies_cfg_test_unless_cfg_test() { + let match = + alt getopts::getopts(["--test", "--cfg=test"], opts()) { + ok(m) { m } + }; + let sessopts = build_session_options(match); + let sess = build_session(sessopts, ""); + let cfg = build_configuration(sess, "whatever", "whatever"); + let test_items = attr::find_meta_items_by_name(cfg, "test"); + assert (vec::len(test_items) == 1u); + } +} + +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: diff --git a/src/comp/driver/rustc.rs b/src/comp/driver/rustc.rs index feb850fc8fc..aad129b6ac8 100644 --- a/src/comp/driver/rustc.rs +++ b/src/comp/driver/rustc.rs @@ -1,290 +1,13 @@ - +use std; +use rustc; // -*- rust -*- -import metadata::{creader, cstore}; -import syntax::parse::{parser}; -import syntax::{ast, codemap}; -import front::attr; -import middle::{trans, resolve, freevars, kind, ty, typeck, fn_usage, - last_use}; -import syntax::print::{pp, pprust}; -import util::{ppaux, filesearch}; -import back::link; -import core::{option, str, vec, int, result}; +import core::{option, str, vec, result}; import result::{ok, err}; -import std::{fs, io, getopts}; +import std::{io, getopts}; import option::{some, none}; -import getopts::{optopt, optmulti, optflag, optflagopt, opt_present}; -import back::{x86, x86_64}; - -tag pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; } - -fn default_configuration(sess: session::session, argv0: str, input: str) -> - ast::crate_cfg { - let libc = - alt sess.get_targ_cfg().os { - session::os_win32. { "msvcrt.dll" } - session::os_macos. { "libc.dylib" } - session::os_linux. { "libc.so.6" } - _ { "libc.so" } - }; - - let mk = attr::mk_name_value_item_str; - - let arch = alt sess.get_targ_cfg().arch { - session::arch_x86. { "x86" } - session::arch_x86_64. { "x86_64" } - session::arch_arm. { "arm" } - }; - - ret [ // Target bindings. - mk("target_os", std::os::target_os()), - mk("target_arch", arch), - mk("target_libc", libc), - // Build bindings. - mk("build_compiler", argv0), - mk("build_input", input)]; -} - -fn build_configuration(sess: session::session, argv0: str, input: str) -> - ast::crate_cfg { - // Combine the configuration requested by the session (command line) with - // some default and generated configuration items - let default_cfg = default_configuration(sess, argv0, input); - let user_cfg = sess.get_opts().cfg; - // If the user wants a test runner, then add the test cfg - let gen_cfg = - { - if sess.get_opts().test && !attr::contains_name(user_cfg, "test") - { - [attr::mk_word_item("test")] - } else { [] } - }; - ret user_cfg + gen_cfg + default_cfg; -} - -// Convert strings provided as --cfg [cfgspec] into a crate_cfg -fn parse_cfgspecs(cfgspecs: [str]) -> ast::crate_cfg { - // FIXME: It would be nice to use the parser to parse all varieties of - // meta_item here. At the moment we just support the meta_word variant. - let words = []; - for s: str in cfgspecs { words += [attr::mk_word_item(s)]; } - ret words; -} - -fn input_is_stdin(filename: str) -> bool { filename == "-" } - -fn parse_input(sess: session::session, cfg: ast::crate_cfg, input: str) -> - @ast::crate { - if !input_is_stdin(input) { - parser::parse_crate_from_file(input, cfg, sess.get_parse_sess()) - } else { parse_input_src(sess, cfg, input).crate } -} - -fn parse_input_src(sess: session::session, cfg: ast::crate_cfg, infile: str) - -> {crate: @ast::crate, src: str} { - let srcbytes = if infile != "-" { - alt io::file_reader(infile) { - result::ok(reader) { reader } - result::err(e) { - sess.fatal(e) - } - } - } else { - io::stdin() - }.read_whole_stream(); - let src = str::unsafe_from_bytes(srcbytes); - let crate = - parser::parse_crate_from_source_str(infile, src, cfg, - sess.get_parse_sess()); - ret {crate: crate, src: src}; -} - -fn time(do_it: bool, what: str, thunk: fn@() -> T) -> T { - if !do_it { ret thunk(); } - let start = std::time::precise_time_s(); - let rv = thunk(); - let end = std::time::precise_time_s(); - log_err #fmt["time: %s took %s s", what, - float::to_str(end - start, 3u)]; - ret rv; -} - -fn inject_libcore_reference(sess: session::session, - crate: @ast::crate) -> @ast::crate { - - fn spanned(x: T) -> @ast::spanned { - ret @{node: x, - span: {lo: 0u, hi: 0u, - expanded_from: codemap::os_none}}; - } - - let n1 = sess.next_node_id(); - let n2 = sess.next_node_id(); - - let vi1 = spanned(ast::view_item_use("core", [], n1)); - let vi2 = spanned(ast::view_item_import_glob(@["core"], n2)); - - let vis = [vi1, vi2] + crate.node.module.view_items; - - ret @{node: {module: { view_items: vis with crate.node.module } - with crate.node} with *crate } -} - - -fn compile_input(sess: session::session, cfg: ast::crate_cfg, input: str, - outdir: option::t, output: option::t) { - - let time_passes = sess.get_opts().time_passes; - let crate = - time(time_passes, "parsing", bind parse_input(sess, cfg, input)); - if sess.get_opts().parse_only { ret; } - - sess.set_building_library(crate); - - crate = - time(time_passes, "configuration", - bind front::config::strip_unconfigured_items(crate)); - if sess.get_opts().test { - crate = - time(time_passes, "building test harness", - bind front::test::modify_for_testing(sess, crate)); - } - crate = - time(time_passes, "expansion", - bind syntax::ext::expand::expand_crate(sess, crate)); - - if sess.get_opts().libcore { - crate = inject_libcore_reference(sess, crate); - } - - let ast_map = - time(time_passes, "ast indexing", - bind middle::ast_map::map_crate(*crate)); - time(time_passes, "external crate/lib resolution", - bind creader::read_crates(sess, *crate)); - let {def_map, exp_map, impl_map} = - time(time_passes, "resolution", - bind resolve::resolve_crate(sess, ast_map, crate)); - let freevars = - time(time_passes, "freevar finding", - bind freevars::annotate_freevars(def_map, crate)); - time(time_passes, "const checking", - bind middle::check_const::check_crate(sess, crate)); - let ty_cx = ty::mk_ctxt(sess, def_map, ast_map, freevars); - let method_map = time(time_passes, "typechecking", - bind typeck::check_crate(ty_cx, impl_map, crate)); - time(time_passes, "block-use checking", - bind middle::block_use::check_crate(ty_cx, crate)); - time(time_passes, "function usage", - bind fn_usage::check_crate_fn_usage(ty_cx, crate)); - time(time_passes, "alt checking", - bind middle::check_alt::check_crate(ty_cx, crate)); - time(time_passes, "typestate checking", - bind middle::tstate::ck::check_crate(ty_cx, crate)); - let mut_map = - time(time_passes, "mutability checking", - bind middle::mut::check_crate(ty_cx, crate)); - let (copy_map, ref_map) = - time(time_passes, "alias checking", - bind middle::alias::check_crate(ty_cx, crate)); - let last_uses = time(time_passes, "last use finding", - bind last_use::find_last_uses(crate, def_map, ref_map, ty_cx)); - time(time_passes, "kind checking", - bind kind::check_crate(ty_cx, method_map, last_uses, crate)); - if sess.get_opts().no_trans { ret; } - - let outputs = build_output_filenames(input, outdir, output, sess); - - let (llmod, link_meta) = - time(time_passes, "translation", - bind trans::trans_crate(sess, crate, ty_cx, - outputs.obj_filename, exp_map, ast_map, - mut_map, copy_map, last_uses, - method_map)); - time(time_passes, "LLVM passes", - bind link::write::run_passes(sess, llmod, outputs.obj_filename)); - - let stop_after_codegen = - sess.get_opts().output_type != link::output_type_exe || - sess.get_opts().static && sess.building_library(); - - if stop_after_codegen { ret; } - - time(time_passes, "Linking", - bind link::link_binary(sess, outputs.obj_filename, - outputs.out_filename, link_meta)); -} - -fn pretty_print_input(sess: session::session, cfg: ast::crate_cfg, input: str, - ppm: pp_mode) { - fn ann_paren_for_expr(node: pprust::ann_node) { - alt node { pprust::node_expr(s, expr) { pprust::popen(s); } _ { } } - } - fn ann_typed_post(tcx: ty::ctxt, node: pprust::ann_node) { - alt node { - pprust::node_expr(s, expr) { - pp::space(s.s); - pp::word(s.s, "as"); - pp::space(s.s); - pp::word(s.s, ppaux::ty_to_str(tcx, ty::expr_ty(tcx, expr))); - pprust::pclose(s); - } - _ { } - } - } - fn ann_identified_post(node: pprust::ann_node) { - alt node { - pprust::node_item(s, item) { - pp::space(s.s); - pprust::synth_comment(s, int::to_str(item.id, 10u)); - } - pprust::node_block(s, blk) { - pp::space(s.s); - pprust::synth_comment(s, - "block " + int::to_str(blk.node.id, 10u)); - } - pprust::node_expr(s, expr) { - pp::space(s.s); - pprust::synth_comment(s, int::to_str(expr.id, 10u)); - pprust::pclose(s); - } - _ { } - } - } - - // Because the pretty printer needs to make a pass over the source - // to collect comments and literals, and we need to support reading - // from stdin, we're going to just suck the source into a string - // so both the parser and pretty-printer can use it. - let crate_src = parse_input_src(sess, cfg, input); - let crate = crate_src.crate; - let src = crate_src.src; - - let ann; - alt ppm { - ppm_expanded. { - crate = syntax::ext::expand::expand_crate(sess, crate); - ann = pprust::no_ann(); - } - ppm_typed. { - crate = syntax::ext::expand::expand_crate(sess, crate); - let amap = middle::ast_map::map_crate(*crate); - let {def_map, impl_map, _} = - resolve::resolve_crate(sess, amap, crate); - let freevars = freevars::annotate_freevars(def_map, crate); - let ty_cx = ty::mk_ctxt(sess, def_map, amap, freevars); - typeck::check_crate(ty_cx, impl_map, crate); - ann = {pre: ann_paren_for_expr, post: bind ann_typed_post(ty_cx, _)}; - } - ppm_identified. { - ann = {pre: ann_paren_for_expr, post: ann_identified_post}; - } - ppm_normal. { ann = pprust::no_ann(); } - } - pprust::print_crate(sess.get_codemap(), crate, input, - io::string_reader(src), io::stdout(), ann); -} +import getopts::{opt_present}; +import rustc::driver::driver::*; fn version(argv0: str) { let vers = "unknown version"; @@ -336,290 +59,6 @@ options: "); } -fn get_os(triple: str) -> session::os { - ret if str::find(triple, "win32") >= 0 || - str::find(triple, "mingw32") >= 0 { - session::os_win32 - } else if str::find(triple, "darwin") >= 0 { - session::os_macos - } else if str::find(triple, "linux") >= 0 { - session::os_linux - } else { early_error("Unknown operating system!") }; -} - -fn get_arch(triple: str) -> session::arch { - ret if str::find(triple, "i386") >= 0 || str::find(triple, "i486") >= 0 || - str::find(triple, "i586") >= 0 || - str::find(triple, "i686") >= 0 || - str::find(triple, "i786") >= 0 { - session::arch_x86 - } else if str::find(triple, "x86_64") >= 0 { - session::arch_x86_64 - } else if str::find(triple, "arm") >= 0 || - str::find(triple, "xscale") >= 0 { - session::arch_arm - } else { early_error("Unknown architecture! " + triple) }; -} - -fn build_target_config(sopts: @session::options) -> @session::config { - let os = get_os(sopts.target_triple); - let arch = get_arch(sopts.target_triple); - let (int_type, uint_type, float_type) = alt arch { - session::arch_x86. {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} - session::arch_x86_64. {(ast::ty_i64, ast::ty_u64, ast::ty_f64)} - session::arch_arm. {(ast::ty_i32, ast::ty_u32, ast::ty_f64)} - }; - let target_strs = alt arch { - session::arch_x86. {x86::get_target_strs(os)} - session::arch_x86_64. {x86_64::get_target_strs(os)} - session::arch_arm. {x86::get_target_strs(os)} - }; - let target_cfg: @session::config = - @{os: os, arch: arch, target_strs: target_strs, int_type: int_type, - uint_type: uint_type, float_type: float_type}; - ret target_cfg; -} - -fn host_triple() -> str { - // Get the host triple out of the build environment. This ensures that our - // idea of the host triple is the same as for the set of libraries we've - // actually built. We can't just take LLVM's host triple because they - // normalize all ix86 architectures to i386. - // FIXME: Instead of grabbing the host triple we really should be - // grabbing (at compile time) the target triple that this rustc is - // built with and calling that (at runtime) the host triple. - let ht = #env("CFG_HOST_TRIPLE"); - ret ht != "" ? ht : fail "rustc built without CFG_HOST_TRIPLE"; -} - -fn build_session_options(match: getopts::match) - -> @session::options { - let crate_type = if opt_present(match, "lib") { - session::lib_crate - } else if opt_present(match, "bin") { - session::bin_crate - } else { - session::unknown_crate - }; - let static = opt_present(match, "static"); - - let parse_only = opt_present(match, "parse-only"); - let no_trans = opt_present(match, "no-trans"); - - let output_type = - if parse_only || no_trans { - link::output_type_none - } else if opt_present(match, "S") && opt_present(match, "emit-llvm") { - link::output_type_llvm_assembly - } else if opt_present(match, "S") { - link::output_type_assembly - } else if opt_present(match, "c") { - link::output_type_object - } else if opt_present(match, "emit-llvm") { - link::output_type_bitcode - } else { link::output_type_exe }; - let libcore = !opt_present(match, "no-core"); - let verify = !opt_present(match, "no-verify"); - let save_temps = opt_present(match, "save-temps"); - let extra_debuginfo = opt_present(match, "xg"); - let debuginfo = opt_present(match, "g") || extra_debuginfo; - let stats = opt_present(match, "stats"); - let time_passes = opt_present(match, "time-passes"); - let time_llvm_passes = opt_present(match, "time-llvm-passes"); - let sysroot_opt = getopts::opt_maybe_str(match, "sysroot"); - let target_opt = getopts::opt_maybe_str(match, "target"); - let no_asm_comments = getopts::opt_present(match, "no-asm-comments"); - alt output_type { - // unless we're emitting huamn-readable assembly, omit comments. - link::output_type_llvm_assembly. | link::output_type_assembly. {} - _ { no_asm_comments = true; } - } - let opt_level: uint = - if opt_present(match, "O") { - if opt_present(match, "opt-level") { - early_error("-O and --opt-level both provided"); - } - 2u - } else if opt_present(match, "opt-level") { - alt getopts::opt_str(match, "opt-level") { - "0" { 0u } - "1" { 1u } - "2" { 2u } - "3" { 3u } - _ { - early_error("optimization level needs " + - "to be between 0-3") - } - } - } else { 0u }; - let target = - alt target_opt { - none. { host_triple() } - some(s) { s } - }; - - let addl_lib_search_paths = getopts::opt_strs(match, "L"); - let cfg = parse_cfgspecs(getopts::opt_strs(match, "cfg")); - let test = opt_present(match, "test"); - let do_gc = opt_present(match, "gc"); - let warn_unused_imports = opt_present(match, "warn-unused-imports"); - let sopts: @session::options = - @{crate_type: crate_type, - static: static, - libcore: libcore, - optimize: opt_level, - debuginfo: debuginfo, - extra_debuginfo: extra_debuginfo, - verify: verify, - save_temps: save_temps, - stats: stats, - time_passes: time_passes, - time_llvm_passes: time_llvm_passes, - output_type: output_type, - addl_lib_search_paths: addl_lib_search_paths, - maybe_sysroot: sysroot_opt, - target_triple: target, - cfg: cfg, - test: test, - parse_only: parse_only, - no_trans: no_trans, - do_gc: do_gc, - no_asm_comments: no_asm_comments, - warn_unused_imports: warn_unused_imports}; - ret sopts; -} - -fn build_session(sopts: @session::options, input: str) -> session::session { - let target_cfg = build_target_config(sopts); - let cstore = cstore::mk_cstore(); - let filesearch = filesearch::mk_filesearch( - sopts.maybe_sysroot, - sopts.target_triple, - sopts.addl_lib_search_paths); - ret session::session(target_cfg, sopts, cstore, - @{cm: codemap::new_codemap(), mutable next_id: 1}, - none, 0u, filesearch, false, fs::dirname(input)); -} - -fn parse_pretty(sess: session::session, &&name: str) -> pp_mode { - if str::eq(name, "normal") { - ret ppm_normal; - } else if str::eq(name, "expanded") { - ret ppm_expanded; - } else if str::eq(name, "typed") { - ret ppm_typed; - } else if str::eq(name, "identified") { ret ppm_identified; } - sess.fatal("argument to `pretty` must be one of `normal`, `typed`, or " + - "`identified`"); -} - -fn opts() -> [getopts::opt] { - ret [optflag("h"), optflag("help"), optflag("v"), optflag("version"), - optflag("emit-llvm"), optflagopt("pretty"), - optflag("ls"), optflag("parse-only"), optflag("no-trans"), - optflag("O"), optopt("opt-level"), optmulti("L"), optflag("S"), - optopt("o"), optopt("out-dir"), optflag("xg"), - optflag("c"), optflag("g"), optflag("save-temps"), - optopt("sysroot"), optopt("target"), optflag("stats"), - optflag("time-passes"), optflag("time-llvm-passes"), - optflag("no-verify"), - optmulti("cfg"), optflag("test"), - optflag("no-core"), - optflag("lib"), optflag("bin"), optflag("static"), optflag("gc"), - optflag("no-asm-comments"), - optflag("warn-unused-imports")]; -} - -fn build_output_filenames(ifile: str, - odir: option::t, - ofile: option::t, - sess: session::session) - -> @{out_filename: str, obj_filename:str} { - let obj_path = ""; - let out_path: str = ""; - let sopts = sess.get_opts(); - let stop_after_codegen = - sopts.output_type != link::output_type_exe || - sopts.static && sess.building_library(); - - - let obj_suffix = - alt sopts.output_type { - link::output_type_none. { "none" } - link::output_type_bitcode. { "bc" } - link::output_type_assembly. { "s" } - link::output_type_llvm_assembly. { "ll" } - // Object and exe output both use the '.o' extension here - link::output_type_object. | link::output_type_exe. { - "o" - } - }; - - alt ofile { - none. { - // "-" as input file will cause the parser to read from stdin so we - // have to make up a name - // We want to toss everything after the final '.' - let dirname = alt odir { - some(d) { d } - none. { - if input_is_stdin(ifile) { - std::os::getcwd() - } else { - fs::dirname(ifile) - } - } - }; - - let (base_path, _) = if !input_is_stdin(ifile) { - fs::splitext(ifile) - } else { - (fs::connect(dirname, "rust_out"), "") - }; - - - if sess.building_library() { - let basename = fs::basename(base_path); - let dylibname = std::os::dylib_filename(basename); - out_path = fs::connect(dirname, dylibname); - obj_path = fs::connect(dirname, basename + "." + obj_path); - } else { - out_path = base_path; - obj_path = base_path + "." + obj_suffix; - } - } - - some(out_file) { - out_path = out_file; - obj_path = if stop_after_codegen { - out_file - } else { - let (base, _) = fs::splitext(out_file); - let modified = base + "." + obj_suffix; - modified - }; - - if sess.building_library() { - // FIXME: We might want to warn here; we're actually not going to - // respect the user's choice of library name when it comes time to - // link, we'll be linking to lib--.so no - // matter what. - } - - if odir != none { - sess.warn("Ignoring --out-dir flag due to -o flag."); - } - } - } - ret @{out_filename: out_path, - obj_filename: obj_path}; -} - -fn early_error(msg: str) -> ! { - codemap::print_diagnostic("", codemap::error, msg); - fail; -} - fn main(args: [str]) { let args = args, binary = vec::shift(args); let match = @@ -658,45 +97,13 @@ fn main(args: [str]) { } let ls = opt_present(match, "ls"); if ls { - metadata::creader::list_file_metadata(sess, ifile, io::stdout()); + list_metadata(sess, ifile, io::stdout()); ret; } compile_input(sess, cfg, ifile, odir, ofile); } -#[cfg(test)] -mod test { - - // When the user supplies --test we should implicitly supply --cfg test - #[test] - fn test_switch_implies_cfg_test() { - let match = - alt getopts::getopts(["--test"], opts()) { - ok(m) { m } - }; - let sessopts = build_session_options(match); - let sess = build_session(sessopts, ""); - let cfg = build_configuration(sess, "whatever", "whatever"); - assert (attr::contains_name(cfg, "test")); - } - - // When the user supplies --test and --cfg test, don't implicitly add - // another --cfg test - #[test] - fn test_switch_implies_cfg_test_unless_cfg_test() { - let match = - alt getopts::getopts(["--test", "--cfg=test"], opts()) { - ok(m) { m } - }; - let sessopts = build_session_options(match); - let sess = build_session(sessopts, ""); - let cfg = build_configuration(sess, "whatever", "whatever"); - let test_items = attr::find_meta_items_by_name(cfg, "test"); - assert (vec::len(test_items) == 1u); - } -} - // Local Variables: // mode: rust // fill-column: 78; diff --git a/src/comp/rustc.rc b/src/comp/rustc.rc index 0ddfb970ed1..883d8b6f046 100644 --- a/src/comp/rustc.rc +++ b/src/comp/rustc.rc @@ -121,7 +121,7 @@ mod metadata { } mod driver { - mod rustc; + mod driver; mod session; }