1471d932a9
this makes sure the checks run before typeck (which might use the constant or const function to calculate an array length) and gives prettier error messages in case of for loops and such (since they aren't expanded yet).
1122 lines
45 KiB
Rust
1122 lines
45 KiB
Rust
// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use rustc::front;
|
|
use rustc::front::map as hir_map;
|
|
use rustc_mir as mir;
|
|
use rustc_mir::mir_map::MirMap;
|
|
use rustc::session::Session;
|
|
use rustc::session::config::{self, Input, OutputFilenames, OutputType};
|
|
use rustc::session::search_paths::PathKind;
|
|
use rustc::lint;
|
|
use rustc::middle::{stability, ty, reachable};
|
|
use rustc::middle::dependency_format;
|
|
use rustc::middle;
|
|
use rustc::util::common::time;
|
|
use rustc_borrowck as borrowck;
|
|
use rustc_resolve as resolve;
|
|
use rustc_metadata::macro_import;
|
|
use rustc_metadata::creader::LocalCrateReader;
|
|
use rustc_metadata::cstore::CStore;
|
|
use rustc_trans::back::link;
|
|
use rustc_trans::back::write;
|
|
use rustc_trans::trans;
|
|
use rustc_typeck as typeck;
|
|
use rustc_privacy;
|
|
use rustc_plugin::registry::Registry;
|
|
use rustc_plugin as plugin;
|
|
use rustc_front::hir;
|
|
use rustc_front::lowering::{lower_crate, LoweringContext};
|
|
use super::Compilation;
|
|
|
|
use serialize::json;
|
|
|
|
use std::collections::HashMap;
|
|
use std::env;
|
|
use std::ffi::{OsString, OsStr};
|
|
use std::fs;
|
|
use std::io::{self, Write};
|
|
use std::path::{Path, PathBuf};
|
|
use syntax::ast::{self, NodeIdAssigner};
|
|
use syntax::attr;
|
|
use syntax::attr::AttrMetaMethods;
|
|
use syntax::diagnostics;
|
|
use syntax::fold::Folder;
|
|
use syntax::parse;
|
|
use syntax::parse::token;
|
|
use syntax::util::node_count::NodeCounter;
|
|
use syntax::visit;
|
|
use syntax;
|
|
use syntax_ext;
|
|
|
|
pub fn compile_input(sess: Session,
|
|
cstore: &CStore,
|
|
cfg: ast::CrateConfig,
|
|
input: &Input,
|
|
outdir: &Option<PathBuf>,
|
|
output: &Option<PathBuf>,
|
|
addl_plugins: Option<Vec<String>>,
|
|
control: CompileController) {
|
|
macro_rules! controller_entry_point{($point: ident, $tsess: expr, $make_state: expr) => ({
|
|
let state = $make_state;
|
|
(control.$point.callback)(state);
|
|
|
|
$tsess.abort_if_errors();
|
|
if control.$point.stop == Compilation::Stop {
|
|
return;
|
|
}
|
|
})}
|
|
|
|
// We need nested scopes here, because the intermediate results can keep
|
|
// large chunks of memory alive and we want to free them as soon as
|
|
// possible to keep the peak memory usage low
|
|
let result = {
|
|
let (outputs, expanded_crate, id) = {
|
|
let krate = phase_1_parse_input(&sess, cfg, input);
|
|
|
|
controller_entry_point!(after_parse,
|
|
sess,
|
|
CompileState::state_after_parse(input, &sess, outdir, &krate));
|
|
|
|
let outputs = build_output_filenames(input, outdir, output, &krate.attrs, &sess);
|
|
let id = link::find_crate_name(Some(&sess), &krate.attrs, input);
|
|
let expanded_crate = match phase_2_configure_and_expand(&sess,
|
|
&cstore,
|
|
krate,
|
|
&id[..],
|
|
addl_plugins) {
|
|
None => return,
|
|
Some(k) => k,
|
|
};
|
|
|
|
(outputs, expanded_crate, id)
|
|
};
|
|
|
|
controller_entry_point!(after_expand,
|
|
sess,
|
|
CompileState::state_after_expand(input,
|
|
&sess,
|
|
outdir,
|
|
&expanded_crate,
|
|
&id[..]));
|
|
|
|
let expanded_crate = assign_node_ids(&sess, expanded_crate);
|
|
// Lower ast -> hir.
|
|
let lcx = LoweringContext::new(&sess, Some(&expanded_crate));
|
|
let mut hir_forest = time(sess.time_passes(),
|
|
"lowering ast -> hir",
|
|
|| hir_map::Forest::new(lower_crate(&lcx, &expanded_crate)));
|
|
|
|
// Discard MTWT tables that aren't required past lowering to HIR.
|
|
if !sess.opts.debugging_opts.keep_mtwt_tables &&
|
|
!sess.opts.debugging_opts.save_analysis {
|
|
syntax::ext::mtwt::clear_tables();
|
|
}
|
|
|
|
let arenas = ty::CtxtArenas::new();
|
|
let hir_map = make_map(&sess, &mut hir_forest);
|
|
|
|
write_out_deps(&sess, &outputs, &id);
|
|
|
|
controller_entry_point!(after_write_deps,
|
|
sess,
|
|
CompileState::state_after_write_deps(input,
|
|
&sess,
|
|
outdir,
|
|
&hir_map,
|
|
&expanded_crate,
|
|
&hir_map.krate(),
|
|
&id[..],
|
|
&lcx));
|
|
|
|
time(sess.time_passes(), "attribute checking", || {
|
|
front::check_attr::check_crate(&sess, &expanded_crate);
|
|
});
|
|
|
|
time(sess.time_passes(),
|
|
"early lint checks",
|
|
|| lint::check_ast_crate(&sess, &expanded_crate));
|
|
|
|
let opt_crate = if sess.opts.debugging_opts.keep_ast ||
|
|
sess.opts.debugging_opts.save_analysis {
|
|
Some(&expanded_crate)
|
|
} else {
|
|
drop(expanded_crate);
|
|
None
|
|
};
|
|
|
|
phase_3_run_analysis_passes(&sess,
|
|
&cstore,
|
|
hir_map,
|
|
&arenas,
|
|
&id,
|
|
control.make_glob_map,
|
|
|tcx, mir_map, analysis| {
|
|
|
|
{
|
|
let state =
|
|
CompileState::state_after_analysis(input,
|
|
&tcx.sess,
|
|
outdir,
|
|
opt_crate,
|
|
tcx.map.krate(),
|
|
&analysis,
|
|
&mir_map,
|
|
tcx,
|
|
&lcx,
|
|
&id);
|
|
(control.after_analysis.callback)(state);
|
|
|
|
tcx.sess.abort_if_errors();
|
|
if control.after_analysis.stop == Compilation::Stop {
|
|
return Err(());
|
|
}
|
|
}
|
|
|
|
if log_enabled!(::log::INFO) {
|
|
println!("Pre-trans");
|
|
tcx.print_debug_stats();
|
|
}
|
|
let trans = phase_4_translate_to_llvm(tcx,
|
|
mir_map,
|
|
analysis);
|
|
|
|
if log_enabled!(::log::INFO) {
|
|
println!("Post-trans");
|
|
tcx.print_debug_stats();
|
|
}
|
|
|
|
// Discard interned strings as they are no longer required.
|
|
token::get_ident_interner().clear();
|
|
|
|
Ok((outputs, trans))
|
|
})
|
|
};
|
|
|
|
let (outputs, trans) = if let Ok(out) = result {
|
|
out
|
|
} else {
|
|
return;
|
|
};
|
|
|
|
phase_5_run_llvm_passes(&sess, &trans, &outputs);
|
|
|
|
controller_entry_point!(after_llvm,
|
|
sess,
|
|
CompileState::state_after_llvm(input, &sess, outdir, &trans));
|
|
|
|
phase_6_link_output(&sess, &trans, &outputs);
|
|
}
|
|
|
|
/// The name used for source code that doesn't originate in a file
|
|
/// (e.g. source from stdin or a string)
|
|
pub fn anon_src() -> String {
|
|
"<anon>".to_string()
|
|
}
|
|
|
|
pub fn source_name(input: &Input) -> String {
|
|
match *input {
|
|
// FIXME (#9639): This needs to handle non-utf8 paths
|
|
Input::File(ref ifile) => ifile.to_str().unwrap().to_string(),
|
|
Input::Str(_) => anon_src(),
|
|
}
|
|
}
|
|
|
|
/// CompileController is used to customise compilation, it allows compilation to
|
|
/// be stopped and/or to call arbitrary code at various points in compilation.
|
|
/// It also allows for various flags to be set to influence what information gets
|
|
/// collected during compilation.
|
|
///
|
|
/// This is a somewhat higher level controller than a Session - the Session
|
|
/// controls what happens in each phase, whereas the CompileController controls
|
|
/// whether a phase is run at all and whether other code (from outside the
|
|
/// the compiler) is run between phases.
|
|
///
|
|
/// Note that if compilation is set to stop and a callback is provided for a
|
|
/// given entry point, the callback is called before compilation is stopped.
|
|
///
|
|
/// Expect more entry points to be added in the future.
|
|
pub struct CompileController<'a> {
|
|
pub after_parse: PhaseController<'a>,
|
|
pub after_expand: PhaseController<'a>,
|
|
pub after_write_deps: PhaseController<'a>,
|
|
pub after_analysis: PhaseController<'a>,
|
|
pub after_llvm: PhaseController<'a>,
|
|
|
|
pub make_glob_map: resolve::MakeGlobMap,
|
|
}
|
|
|
|
impl<'a> CompileController<'a> {
|
|
pub fn basic() -> CompileController<'a> {
|
|
CompileController {
|
|
after_parse: PhaseController::basic(),
|
|
after_expand: PhaseController::basic(),
|
|
after_write_deps: PhaseController::basic(),
|
|
after_analysis: PhaseController::basic(),
|
|
after_llvm: PhaseController::basic(),
|
|
make_glob_map: resolve::MakeGlobMap::No,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct PhaseController<'a> {
|
|
pub stop: Compilation,
|
|
pub callback: Box<Fn(CompileState) -> () + 'a>,
|
|
}
|
|
|
|
impl<'a> PhaseController<'a> {
|
|
pub fn basic() -> PhaseController<'a> {
|
|
PhaseController {
|
|
stop: Compilation::Continue,
|
|
callback: box |_| {},
|
|
}
|
|
}
|
|
}
|
|
|
|
/// State that is passed to a callback. What state is available depends on when
|
|
/// during compilation the callback is made. See the various constructor methods
|
|
/// (`state_*`) in the impl to see which data is provided for any given entry point.
|
|
pub struct CompileState<'a, 'ast: 'a, 'tcx: 'a> {
|
|
pub input: &'a Input,
|
|
pub session: &'a Session,
|
|
pub cfg: Option<&'a ast::CrateConfig>,
|
|
pub krate: Option<&'a ast::Crate>,
|
|
pub crate_name: Option<&'a str>,
|
|
pub output_filenames: Option<&'a OutputFilenames>,
|
|
pub out_dir: Option<&'a Path>,
|
|
pub expanded_crate: Option<&'a ast::Crate>,
|
|
pub hir_crate: Option<&'a hir::Crate>,
|
|
pub ast_map: Option<&'a hir_map::Map<'ast>>,
|
|
pub mir_map: Option<&'a MirMap<'tcx>>,
|
|
pub analysis: Option<&'a ty::CrateAnalysis<'a>>,
|
|
pub tcx: Option<&'a ty::ctxt<'tcx>>,
|
|
pub lcx: Option<&'a LoweringContext<'a>>,
|
|
pub trans: Option<&'a trans::CrateTranslation>,
|
|
}
|
|
|
|
impl<'a, 'ast, 'tcx> CompileState<'a, 'ast, 'tcx> {
|
|
fn empty(input: &'a Input,
|
|
session: &'a Session,
|
|
out_dir: &'a Option<PathBuf>)
|
|
-> CompileState<'a, 'ast, 'tcx> {
|
|
CompileState {
|
|
input: input,
|
|
session: session,
|
|
out_dir: out_dir.as_ref().map(|s| &**s),
|
|
cfg: None,
|
|
krate: None,
|
|
crate_name: None,
|
|
output_filenames: None,
|
|
expanded_crate: None,
|
|
hir_crate: None,
|
|
ast_map: None,
|
|
analysis: None,
|
|
mir_map: None,
|
|
tcx: None,
|
|
lcx: None,
|
|
trans: None,
|
|
}
|
|
}
|
|
|
|
fn state_after_parse(input: &'a Input,
|
|
session: &'a Session,
|
|
out_dir: &'a Option<PathBuf>,
|
|
krate: &'a ast::Crate)
|
|
-> CompileState<'a, 'ast, 'tcx> {
|
|
CompileState { krate: Some(krate), ..CompileState::empty(input, session, out_dir) }
|
|
}
|
|
|
|
fn state_after_expand(input: &'a Input,
|
|
session: &'a Session,
|
|
out_dir: &'a Option<PathBuf>,
|
|
expanded_crate: &'a ast::Crate,
|
|
crate_name: &'a str)
|
|
-> CompileState<'a, 'ast, 'tcx> {
|
|
CompileState {
|
|
crate_name: Some(crate_name),
|
|
expanded_crate: Some(expanded_crate),
|
|
..CompileState::empty(input, session, out_dir)
|
|
}
|
|
}
|
|
|
|
fn state_after_write_deps(input: &'a Input,
|
|
session: &'a Session,
|
|
out_dir: &'a Option<PathBuf>,
|
|
hir_map: &'a hir_map::Map<'ast>,
|
|
krate: &'a ast::Crate,
|
|
hir_crate: &'a hir::Crate,
|
|
crate_name: &'a str,
|
|
lcx: &'a LoweringContext<'a>)
|
|
-> CompileState<'a, 'ast, 'tcx> {
|
|
CompileState {
|
|
crate_name: Some(crate_name),
|
|
ast_map: Some(hir_map),
|
|
krate: Some(krate),
|
|
hir_crate: Some(hir_crate),
|
|
lcx: Some(lcx),
|
|
..CompileState::empty(input, session, out_dir)
|
|
}
|
|
}
|
|
|
|
fn state_after_analysis(input: &'a Input,
|
|
session: &'a Session,
|
|
out_dir: &'a Option<PathBuf>,
|
|
krate: Option<&'a ast::Crate>,
|
|
hir_crate: &'a hir::Crate,
|
|
analysis: &'a ty::CrateAnalysis,
|
|
mir_map: &'a MirMap<'tcx>,
|
|
tcx: &'a ty::ctxt<'tcx>,
|
|
lcx: &'a LoweringContext<'a>,
|
|
crate_name: &'a str)
|
|
-> CompileState<'a, 'ast, 'tcx> {
|
|
CompileState {
|
|
analysis: Some(analysis),
|
|
mir_map: Some(mir_map),
|
|
tcx: Some(tcx),
|
|
krate: krate,
|
|
hir_crate: Some(hir_crate),
|
|
lcx: Some(lcx),
|
|
crate_name: Some(crate_name),
|
|
..CompileState::empty(input, session, out_dir)
|
|
}
|
|
}
|
|
|
|
|
|
fn state_after_llvm(input: &'a Input,
|
|
session: &'a Session,
|
|
out_dir: &'a Option<PathBuf>,
|
|
trans: &'a trans::CrateTranslation)
|
|
-> CompileState<'a, 'ast, 'tcx> {
|
|
CompileState { trans: Some(trans), ..CompileState::empty(input, session, out_dir) }
|
|
}
|
|
}
|
|
|
|
pub fn phase_1_parse_input(sess: &Session, cfg: ast::CrateConfig, input: &Input) -> ast::Crate {
|
|
// These may be left in an incoherent state after a previous compile.
|
|
// `clear_tables` and `get_ident_interner().clear()` can be used to free
|
|
// memory, but they do not restore the initial state.
|
|
syntax::ext::mtwt::reset_tables();
|
|
token::reset_ident_interner();
|
|
|
|
let krate = time(sess.time_passes(), "parsing", || {
|
|
match *input {
|
|
Input::File(ref file) => {
|
|
parse::parse_crate_from_file(&(*file), cfg.clone(), &sess.parse_sess)
|
|
}
|
|
Input::Str(ref src) => {
|
|
parse::parse_crate_from_source_str(anon_src().to_string(),
|
|
src.to_string(),
|
|
cfg.clone(),
|
|
&sess.parse_sess)
|
|
}
|
|
}
|
|
});
|
|
|
|
if sess.opts.debugging_opts.ast_json_noexpand {
|
|
println!("{}", json::as_json(&krate));
|
|
}
|
|
|
|
if sess.opts.debugging_opts.input_stats {
|
|
println!("Lines of code: {}", sess.codemap().count_lines());
|
|
println!("Pre-expansion node count: {}", count_nodes(&krate));
|
|
}
|
|
|
|
if let Some(ref s) = sess.opts.debugging_opts.show_span {
|
|
syntax::show_span::run(sess.diagnostic(), s, &krate);
|
|
}
|
|
|
|
krate
|
|
}
|
|
|
|
fn count_nodes(krate: &ast::Crate) -> usize {
|
|
let mut counter = NodeCounter::new();
|
|
visit::walk_crate(&mut counter, krate);
|
|
counter.count
|
|
}
|
|
|
|
// For continuing compilation after a parsed crate has been
|
|
// modified
|
|
|
|
/// Run the "early phases" of the compiler: initial `cfg` processing,
|
|
/// loading compiler plugins (including those from `addl_plugins`),
|
|
/// syntax expansion, secondary `cfg` expansion, synthesis of a test
|
|
/// harness if one is to be provided and injection of a dependency on the
|
|
/// standard library and prelude.
|
|
///
|
|
/// Returns `None` if we're aborting after handling -W help.
|
|
pub fn phase_2_configure_and_expand(sess: &Session,
|
|
cstore: &CStore,
|
|
mut krate: ast::Crate,
|
|
crate_name: &str,
|
|
addl_plugins: Option<Vec<String>>)
|
|
-> Option<ast::Crate> {
|
|
let time_passes = sess.time_passes();
|
|
|
|
// strip before anything else because crate metadata may use #[cfg_attr]
|
|
// and so macros can depend on configuration variables, such as
|
|
//
|
|
// #[macro_use] #[cfg(foo)]
|
|
// mod bar { macro_rules! baz!(() => {{}}) }
|
|
//
|
|
// baz! should not use this definition unless foo is enabled.
|
|
|
|
let mut feature_gated_cfgs = vec![];
|
|
krate = time(time_passes, "configuration 1", || {
|
|
syntax::config::strip_unconfigured_items(sess.diagnostic(), krate, &mut feature_gated_cfgs)
|
|
});
|
|
|
|
*sess.crate_types.borrow_mut() = collect_crate_types(sess, &krate.attrs);
|
|
*sess.crate_metadata.borrow_mut() = collect_crate_metadata(sess, &krate.attrs);
|
|
|
|
time(time_passes, "recursion limit", || {
|
|
middle::recursion_limit::update_recursion_limit(sess, &krate);
|
|
});
|
|
|
|
time(time_passes, "gated macro checking", || {
|
|
let features = syntax::feature_gate::check_crate_macros(sess.codemap(),
|
|
&sess.parse_sess.span_diagnostic,
|
|
&krate);
|
|
|
|
// these need to be set "early" so that expansion sees `quote` if enabled.
|
|
*sess.features.borrow_mut() = features;
|
|
sess.abort_if_errors();
|
|
});
|
|
|
|
|
|
krate = time(time_passes, "crate injection", || {
|
|
syntax::std_inject::maybe_inject_crates_ref(krate, sess.opts.alt_std_name.clone())
|
|
});
|
|
|
|
let macros = time(time_passes,
|
|
"macro loading",
|
|
|| macro_import::read_macro_defs(sess, &cstore, &krate));
|
|
|
|
let mut addl_plugins = Some(addl_plugins);
|
|
let registrars = time(time_passes, "plugin loading", || {
|
|
plugin::load::load_plugins(sess, &cstore, &krate, addl_plugins.take().unwrap())
|
|
});
|
|
|
|
let mut registry = Registry::new(sess, &krate);
|
|
|
|
time(time_passes, "plugin registration", || {
|
|
if sess.features.borrow().rustc_diagnostic_macros {
|
|
registry.register_macro("__diagnostic_used",
|
|
diagnostics::plugin::expand_diagnostic_used);
|
|
registry.register_macro("__register_diagnostic",
|
|
diagnostics::plugin::expand_register_diagnostic);
|
|
registry.register_macro("__build_diagnostic_array",
|
|
diagnostics::plugin::expand_build_diagnostic_array);
|
|
}
|
|
|
|
for registrar in registrars {
|
|
registry.args_hidden = Some(registrar.args);
|
|
(registrar.fun)(&mut registry);
|
|
}
|
|
});
|
|
|
|
let Registry { syntax_exts, early_lint_passes, late_lint_passes, lint_groups,
|
|
llvm_passes, attributes, .. } = registry;
|
|
|
|
{
|
|
let mut ls = sess.lint_store.borrow_mut();
|
|
for pass in early_lint_passes {
|
|
ls.register_early_pass(Some(sess), true, pass);
|
|
}
|
|
for pass in late_lint_passes {
|
|
ls.register_late_pass(Some(sess), true, pass);
|
|
}
|
|
|
|
for (name, to) in lint_groups {
|
|
ls.register_group(Some(sess), true, name, to);
|
|
}
|
|
|
|
*sess.plugin_llvm_passes.borrow_mut() = llvm_passes;
|
|
*sess.plugin_attributes.borrow_mut() = attributes.clone();
|
|
}
|
|
|
|
// Lint plugins are registered; now we can process command line flags.
|
|
if sess.opts.describe_lints {
|
|
super::describe_lints(&*sess.lint_store.borrow(), true);
|
|
return None;
|
|
}
|
|
sess.lint_store.borrow_mut().process_command_line(sess);
|
|
|
|
// Abort if there are errors from lint processing or a plugin registrar.
|
|
sess.abort_if_errors();
|
|
|
|
krate = time(time_passes, "expansion", || {
|
|
// Windows dlls do not have rpaths, so they don't know how to find their
|
|
// dependencies. It's up to us to tell the system where to find all the
|
|
// dependent dlls. Note that this uses cfg!(windows) as opposed to
|
|
// targ_cfg because syntax extensions are always loaded for the host
|
|
// compiler, not for the target.
|
|
let mut _old_path = OsString::new();
|
|
if cfg!(windows) {
|
|
_old_path = env::var_os("PATH").unwrap_or(_old_path);
|
|
let mut new_path = sess.host_filesearch(PathKind::All)
|
|
.get_dylib_search_paths();
|
|
new_path.extend(env::split_paths(&_old_path));
|
|
env::set_var("PATH", &env::join_paths(new_path).unwrap());
|
|
}
|
|
let features = sess.features.borrow();
|
|
let cfg = syntax::ext::expand::ExpansionConfig {
|
|
crate_name: crate_name.to_string(),
|
|
features: Some(&features),
|
|
recursion_limit: sess.recursion_limit.get(),
|
|
trace_mac: sess.opts.debugging_opts.trace_macros,
|
|
};
|
|
let mut ecx = syntax::ext::base::ExtCtxt::new(&sess.parse_sess,
|
|
krate.config.clone(),
|
|
cfg,
|
|
&mut feature_gated_cfgs);
|
|
syntax_ext::register_builtins(&mut ecx.syntax_env);
|
|
let (ret, macro_names) = syntax::ext::expand::expand_crate(ecx,
|
|
macros,
|
|
syntax_exts,
|
|
krate);
|
|
if cfg!(windows) {
|
|
env::set_var("PATH", &_old_path);
|
|
}
|
|
*sess.available_macros.borrow_mut() = macro_names;
|
|
ret
|
|
});
|
|
|
|
// Needs to go *after* expansion to be able to check the results
|
|
// of macro expansion. This runs before #[cfg] to try to catch as
|
|
// much as possible (e.g. help the programmer avoid platform
|
|
// specific differences)
|
|
time(time_passes, "complete gated feature checking 1", || {
|
|
let features = syntax::feature_gate::check_crate(sess.codemap(),
|
|
&sess.parse_sess.span_diagnostic,
|
|
&krate,
|
|
&attributes,
|
|
sess.opts.unstable_features);
|
|
*sess.features.borrow_mut() = features;
|
|
sess.abort_if_errors();
|
|
});
|
|
|
|
// JBC: make CFG processing part of expansion to avoid this problem:
|
|
|
|
// strip again, in case expansion added anything with a #[cfg].
|
|
krate = time(time_passes, "configuration 2", || {
|
|
syntax::config::strip_unconfigured_items(sess.diagnostic(), krate, &mut feature_gated_cfgs)
|
|
});
|
|
|
|
time(time_passes, "gated configuration checking", || {
|
|
let features = sess.features.borrow();
|
|
feature_gated_cfgs.sort();
|
|
feature_gated_cfgs.dedup();
|
|
for cfg in &feature_gated_cfgs {
|
|
cfg.check_and_emit(sess.diagnostic(), &features, sess.codemap());
|
|
}
|
|
});
|
|
|
|
krate = time(time_passes, "maybe building test harness", || {
|
|
syntax::test::modify_for_testing(&sess.parse_sess, &sess.opts.cfg, krate, sess.diagnostic())
|
|
});
|
|
|
|
krate = time(time_passes,
|
|
"prelude injection",
|
|
|| syntax::std_inject::maybe_inject_prelude(&sess.parse_sess, krate));
|
|
|
|
time(time_passes,
|
|
"checking that all macro invocations are gone",
|
|
|| syntax::ext::expand::check_for_macros(&sess.parse_sess, &krate));
|
|
|
|
time(time_passes,
|
|
"checking for inline asm in case the target doesn't support it",
|
|
|| ::rustc_passes::no_asm::check_crate(sess, &krate));
|
|
|
|
// One final feature gating of the true AST that gets compiled
|
|
// later, to make sure we've got everything (e.g. configuration
|
|
// can insert new attributes via `cfg_attr`)
|
|
time(time_passes, "complete gated feature checking 2", || {
|
|
let features = syntax::feature_gate::check_crate(sess.codemap(),
|
|
&sess.parse_sess.span_diagnostic,
|
|
&krate,
|
|
&attributes,
|
|
sess.opts.unstable_features);
|
|
*sess.features.borrow_mut() = features;
|
|
sess.abort_if_errors();
|
|
});
|
|
|
|
time(time_passes,
|
|
"const fn bodies and arguments",
|
|
|| ::rustc_passes::const_fn::check_crate(sess, &krate));
|
|
|
|
if sess.opts.debugging_opts.input_stats {
|
|
println!("Post-expansion node count: {}", count_nodes(&krate));
|
|
}
|
|
|
|
Some(krate)
|
|
}
|
|
|
|
pub fn assign_node_ids(sess: &Session, krate: ast::Crate) -> ast::Crate {
|
|
struct NodeIdAssigner<'a> {
|
|
sess: &'a Session,
|
|
}
|
|
|
|
impl<'a> Folder for NodeIdAssigner<'a> {
|
|
fn new_id(&mut self, old_id: ast::NodeId) -> ast::NodeId {
|
|
assert_eq!(old_id, ast::DUMMY_NODE_ID);
|
|
self.sess.next_node_id()
|
|
}
|
|
}
|
|
|
|
let krate = time(sess.time_passes(),
|
|
"assigning node ids",
|
|
|| NodeIdAssigner { sess: sess }.fold_crate(krate));
|
|
|
|
if sess.opts.debugging_opts.ast_json {
|
|
println!("{}", json::as_json(&krate));
|
|
}
|
|
|
|
krate
|
|
}
|
|
|
|
pub fn make_map<'ast>(sess: &Session,
|
|
forest: &'ast mut hir_map::Forest)
|
|
-> hir_map::Map<'ast> {
|
|
// Construct the HIR map
|
|
time(sess.time_passes(),
|
|
"indexing hir",
|
|
move || hir_map::map_crate(forest))
|
|
}
|
|
|
|
/// Run the resolution, typechecking, region checking and other
|
|
/// miscellaneous analysis passes on the crate. Return various
|
|
/// structures carrying the results of the analysis.
|
|
pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
|
|
cstore: &CStore,
|
|
hir_map: hir_map::Map<'tcx>,
|
|
arenas: &'tcx ty::CtxtArenas<'tcx>,
|
|
name: &str,
|
|
make_glob_map: resolve::MakeGlobMap,
|
|
f: F)
|
|
-> R
|
|
where F: for<'a> FnOnce(&'a ty::ctxt<'tcx>, MirMap<'tcx>, ty::CrateAnalysis) -> R
|
|
{
|
|
let time_passes = sess.time_passes();
|
|
let krate = hir_map.krate();
|
|
|
|
time(time_passes,
|
|
"external crate/lib resolution",
|
|
|| LocalCrateReader::new(sess, cstore, &hir_map).read_crates(krate));
|
|
|
|
let lang_items = time(time_passes,
|
|
"language item collection",
|
|
|| middle::lang_items::collect_language_items(&sess, &hir_map));
|
|
|
|
let resolve::CrateMap {
|
|
def_map,
|
|
freevars,
|
|
export_map,
|
|
trait_map,
|
|
external_exports,
|
|
glob_map,
|
|
} = time(time_passes,
|
|
"resolution",
|
|
|| resolve::resolve_crate(sess, &hir_map, make_glob_map));
|
|
|
|
let named_region_map = time(time_passes,
|
|
"lifetime resolution",
|
|
|| middle::resolve_lifetime::krate(sess, krate, &def_map.borrow()));
|
|
|
|
time(time_passes,
|
|
"looking for entry point",
|
|
|| middle::entry::find_entry_point(sess, &hir_map));
|
|
|
|
sess.plugin_registrar_fn.set(time(time_passes, "looking for plugin registrar", || {
|
|
plugin::build::find_plugin_registrar(sess.diagnostic(), krate)
|
|
}));
|
|
|
|
let region_map = time(time_passes,
|
|
"region resolution",
|
|
|| middle::region::resolve_crate(sess, krate));
|
|
|
|
time(time_passes,
|
|
"loop checking",
|
|
|| middle::check_loop::check_crate(sess, krate));
|
|
|
|
time(time_passes,
|
|
"static item recursion checking",
|
|
|| middle::check_static_recursion::check_crate(sess, krate, &def_map.borrow(), &hir_map));
|
|
|
|
ty::ctxt::create_and_enter(sess,
|
|
arenas,
|
|
def_map,
|
|
named_region_map,
|
|
hir_map,
|
|
freevars,
|
|
region_map,
|
|
lang_items,
|
|
stability::Index::new(krate),
|
|
|tcx| {
|
|
// passes are timed inside typeck
|
|
typeck::check_crate(tcx, trait_map);
|
|
|
|
time(time_passes,
|
|
"const checking",
|
|
|| middle::check_const::check_crate(tcx));
|
|
|
|
let access_levels =
|
|
time(time_passes, "privacy checking", || {
|
|
rustc_privacy::check_crate(tcx,
|
|
&export_map,
|
|
external_exports)
|
|
});
|
|
|
|
// Do not move this check past lint
|
|
time(time_passes, "stability index", || {
|
|
tcx.stability.borrow_mut().build(tcx, krate, &access_levels)
|
|
});
|
|
|
|
time(time_passes,
|
|
"intrinsic checking",
|
|
|| middle::intrinsicck::check_crate(tcx));
|
|
|
|
time(time_passes,
|
|
"effect checking",
|
|
|| middle::effect::check_crate(tcx));
|
|
|
|
time(time_passes,
|
|
"match checking",
|
|
|| middle::check_match::check_crate(tcx));
|
|
|
|
let mir_map =
|
|
time(time_passes,
|
|
"MIR dump",
|
|
|| mir::mir_map::build_mir_for_crate(tcx));
|
|
|
|
time(time_passes,
|
|
"liveness checking",
|
|
|| middle::liveness::check_crate(tcx));
|
|
|
|
time(time_passes,
|
|
"borrow checking",
|
|
|| borrowck::check_crate(tcx));
|
|
|
|
time(time_passes,
|
|
"rvalue checking",
|
|
|| middle::check_rvalues::check_crate(tcx));
|
|
|
|
// Avoid overwhelming user with errors if type checking failed.
|
|
// I'm not sure how helpful this is, to be honest, but it avoids
|
|
// a
|
|
// lot of annoying errors in the compile-fail tests (basically,
|
|
// lint warnings and so on -- kindck used to do this abort, but
|
|
// kindck is gone now). -nmatsakis
|
|
tcx.sess.abort_if_errors();
|
|
|
|
let reachable_map =
|
|
time(time_passes,
|
|
"reachability checking",
|
|
|| reachable::find_reachable(tcx, &access_levels));
|
|
|
|
time(time_passes, "death checking", || {
|
|
middle::dead::check_crate(tcx, &access_levels);
|
|
});
|
|
|
|
let ref lib_features_used =
|
|
time(time_passes,
|
|
"stability checking",
|
|
|| stability::check_unstable_api_usage(tcx));
|
|
|
|
time(time_passes, "unused lib feature checking", || {
|
|
stability::check_unused_or_stable_features(&tcx.sess,
|
|
lib_features_used)
|
|
});
|
|
|
|
time(time_passes,
|
|
"lint checking",
|
|
|| lint::check_crate(tcx, &access_levels));
|
|
|
|
// The above three passes generate errors w/o aborting
|
|
tcx.sess.abort_if_errors();
|
|
|
|
f(tcx,
|
|
mir_map,
|
|
ty::CrateAnalysis {
|
|
export_map: export_map,
|
|
access_levels: access_levels,
|
|
reachable: reachable_map,
|
|
name: name,
|
|
glob_map: glob_map,
|
|
})
|
|
})
|
|
}
|
|
|
|
/// Run the translation phase to LLVM, after which the AST and analysis can
|
|
/// be discarded.
|
|
pub fn phase_4_translate_to_llvm<'tcx>(tcx: &ty::ctxt<'tcx>,
|
|
mut mir_map: MirMap<'tcx>,
|
|
analysis: ty::CrateAnalysis)
|
|
-> trans::CrateTranslation {
|
|
let time_passes = tcx.sess.time_passes();
|
|
|
|
time(time_passes,
|
|
"resolving dependency formats",
|
|
|| dependency_format::calculate(&tcx.sess));
|
|
|
|
time(time_passes,
|
|
"erasing regions from MIR",
|
|
|| mir::transform::erase_regions::erase_regions(tcx, &mut mir_map));
|
|
|
|
// Option dance to work around the lack of stack once closures.
|
|
time(time_passes,
|
|
"translation",
|
|
move || trans::trans_crate(tcx, &mir_map, analysis))
|
|
}
|
|
|
|
/// Run LLVM itself, producing a bitcode file, assembly file or object file
|
|
/// as a side effect.
|
|
pub fn phase_5_run_llvm_passes(sess: &Session,
|
|
trans: &trans::CrateTranslation,
|
|
outputs: &OutputFilenames) {
|
|
if sess.opts.cg.no_integrated_as {
|
|
let mut map = HashMap::new();
|
|
map.insert(OutputType::Assembly, None);
|
|
time(sess.time_passes(),
|
|
"LLVM passes",
|
|
|| write::run_passes(sess, trans, &map, outputs));
|
|
|
|
write::run_assembler(sess, outputs);
|
|
|
|
// Remove assembly source, unless --save-temps was specified
|
|
if !sess.opts.cg.save_temps {
|
|
fs::remove_file(&outputs.temp_path(OutputType::Assembly)).unwrap();
|
|
}
|
|
} else {
|
|
time(sess.time_passes(),
|
|
"LLVM passes",
|
|
|| write::run_passes(sess, trans, &sess.opts.output_types, outputs));
|
|
}
|
|
|
|
sess.abort_if_errors();
|
|
}
|
|
|
|
/// Run the linker on any artifacts that resulted from the LLVM run.
|
|
/// This should produce either a finished executable or library.
|
|
pub fn phase_6_link_output(sess: &Session,
|
|
trans: &trans::CrateTranslation,
|
|
outputs: &OutputFilenames) {
|
|
time(sess.time_passes(),
|
|
"linking",
|
|
|| link::link_binary(sess, trans, outputs, &trans.link.crate_name));
|
|
}
|
|
|
|
fn escape_dep_filename(filename: &str) -> String {
|
|
// Apparently clang and gcc *only* escape spaces:
|
|
// http://llvm.org/klaus/clang/commit/9d50634cfc268ecc9a7250226dd5ca0e945240d4
|
|
filename.replace(" ", "\\ ")
|
|
}
|
|
|
|
fn write_out_deps(sess: &Session, outputs: &OutputFilenames, id: &str) {
|
|
let mut out_filenames = Vec::new();
|
|
for output_type in sess.opts.output_types.keys() {
|
|
let file = outputs.path(*output_type);
|
|
match *output_type {
|
|
OutputType::Exe => {
|
|
for output in sess.crate_types.borrow().iter() {
|
|
let p = link::filename_for_input(sess, *output, id, outputs);
|
|
out_filenames.push(p);
|
|
}
|
|
}
|
|
_ => {
|
|
out_filenames.push(file);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Write out dependency rules to the dep-info file if requested
|
|
if !sess.opts.output_types.contains_key(&OutputType::DepInfo) {
|
|
return;
|
|
}
|
|
let deps_filename = outputs.path(OutputType::DepInfo);
|
|
|
|
let result =
|
|
(|| -> io::Result<()> {
|
|
// Build a list of files used to compile the output and
|
|
// write Makefile-compatible dependency rules
|
|
let files: Vec<String> = sess.codemap()
|
|
.files
|
|
.borrow()
|
|
.iter()
|
|
.filter(|fmap| fmap.is_real_file())
|
|
.filter(|fmap| !fmap.is_imported())
|
|
.map(|fmap| escape_dep_filename(&fmap.name))
|
|
.collect();
|
|
let mut file = try!(fs::File::create(&deps_filename));
|
|
for path in &out_filenames {
|
|
try!(write!(file, "{}: {}\n\n", path.display(), files.join(" ")));
|
|
}
|
|
|
|
// Emit a fake target for each input file to the compilation. This
|
|
// prevents `make` from spitting out an error if a file is later
|
|
// deleted. For more info see #28735
|
|
for path in files {
|
|
try!(writeln!(file, "{}:", path));
|
|
}
|
|
Ok(())
|
|
})();
|
|
|
|
match result {
|
|
Ok(()) => {}
|
|
Err(e) => {
|
|
sess.fatal(&format!("error writing dependencies to `{}`: {}",
|
|
deps_filename.display(),
|
|
e));
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn collect_crate_types(session: &Session, attrs: &[ast::Attribute]) -> Vec<config::CrateType> {
|
|
// Unconditionally collect crate types from attributes to make them used
|
|
let attr_types: Vec<config::CrateType> =
|
|
attrs.iter()
|
|
.filter_map(|a| {
|
|
if a.check_name("crate_type") {
|
|
match a.value_str() {
|
|
Some(ref n) if *n == "rlib" => {
|
|
Some(config::CrateTypeRlib)
|
|
}
|
|
Some(ref n) if *n == "dylib" => {
|
|
Some(config::CrateTypeDylib)
|
|
}
|
|
Some(ref n) if *n == "lib" => {
|
|
Some(config::default_lib_output())
|
|
}
|
|
Some(ref n) if *n == "staticlib" => {
|
|
Some(config::CrateTypeStaticlib)
|
|
}
|
|
Some(ref n) if *n == "bin" => Some(config::CrateTypeExecutable),
|
|
Some(_) => {
|
|
session.add_lint(lint::builtin::UNKNOWN_CRATE_TYPES,
|
|
ast::CRATE_NODE_ID,
|
|
a.span,
|
|
"invalid `crate_type` value".to_string());
|
|
None
|
|
}
|
|
_ => {
|
|
session.struct_span_err(a.span, "`crate_type` requires a value")
|
|
.note("for example: `#![crate_type=\"lib\"]`")
|
|
.emit();
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
// If we're generating a test executable, then ignore all other output
|
|
// styles at all other locations
|
|
if session.opts.test {
|
|
return vec![config::CrateTypeExecutable];
|
|
}
|
|
|
|
// Only check command line flags if present. If no types are specified by
|
|
// command line, then reuse the empty `base` Vec to hold the types that
|
|
// will be found in crate attributes.
|
|
let mut base = session.opts.crate_types.clone();
|
|
if base.is_empty() {
|
|
base.extend(attr_types);
|
|
if base.is_empty() {
|
|
base.push(link::default_output_for_target(session));
|
|
}
|
|
base.sort();
|
|
base.dedup();
|
|
}
|
|
|
|
base.into_iter()
|
|
.filter(|crate_type| {
|
|
let res = !link::invalid_output_for_target(session, *crate_type);
|
|
|
|
if !res {
|
|
session.warn(&format!("dropping unsupported crate type `{}` for target `{}`",
|
|
*crate_type,
|
|
session.opts.target_triple));
|
|
}
|
|
|
|
res
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn collect_crate_metadata(session: &Session, _attrs: &[ast::Attribute]) -> Vec<String> {
|
|
session.opts.cg.metadata.clone()
|
|
}
|
|
|
|
pub fn build_output_filenames(input: &Input,
|
|
odir: &Option<PathBuf>,
|
|
ofile: &Option<PathBuf>,
|
|
attrs: &[ast::Attribute],
|
|
sess: &Session)
|
|
-> OutputFilenames {
|
|
match *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 dirpath = match *odir {
|
|
Some(ref d) => d.clone(),
|
|
None => PathBuf::new(),
|
|
};
|
|
|
|
// If a crate name is present, we use it as the link name
|
|
let stem = sess.opts
|
|
.crate_name
|
|
.clone()
|
|
.or_else(|| attr::find_crate_name(attrs).map(|n| n.to_string()))
|
|
.unwrap_or(input.filestem());
|
|
|
|
OutputFilenames {
|
|
out_directory: dirpath,
|
|
out_filestem: stem,
|
|
single_output_file: None,
|
|
extra: sess.opts.cg.extra_filename.clone(),
|
|
outputs: sess.opts.output_types.clone(),
|
|
}
|
|
}
|
|
|
|
Some(ref out_file) => {
|
|
let unnamed_output_types = sess.opts
|
|
.output_types
|
|
.values()
|
|
.filter(|a| a.is_none())
|
|
.count();
|
|
let ofile = if unnamed_output_types > 1 {
|
|
sess.warn("ignoring specified output filename because multiple outputs were \
|
|
requested");
|
|
None
|
|
} else {
|
|
Some(out_file.clone())
|
|
};
|
|
if *odir != None {
|
|
sess.warn("ignoring --out-dir flag due to -o flag.");
|
|
}
|
|
|
|
let cur_dir = Path::new("");
|
|
|
|
OutputFilenames {
|
|
out_directory: out_file.parent().unwrap_or(cur_dir).to_path_buf(),
|
|
out_filestem: out_file.file_stem()
|
|
.unwrap_or(OsStr::new(""))
|
|
.to_str()
|
|
.unwrap()
|
|
.to_string(),
|
|
single_output_file: ofile,
|
|
extra: sess.opts.cg.extra_filename.clone(),
|
|
outputs: sess.opts.output_types.clone(),
|
|
}
|
|
}
|
|
}
|
|
}
|