user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #43842 - bjorn3:no_llvm_cleanup, r=alexcrichton

Browse source 
Cleanup for "Support compiling rustc without LLVM (try 2)"

This includes a small patch to allow running tests without llvm. Also check if you are not trying to compile a dylib.

cc #42932
r? @alexcrichton
This commit is contained in:
bors 2017-08-14 02:11:18 +00:00
commit e324594844
5 changed files with 142 additions and 139 deletions
Download patch file Download diff file Expand all files Collapse all files

43
src/bootstrap/check.rs
View file

@ -618,12 +618,6 @@ impl Step for Compiletest {
if let Some(ref dir) = build.lldb_python_dir {
cmd.arg("--lldb-python-dir").arg(dir);
}
let llvm_config = build.llvm_config(target);
let llvm_version = output(Command::new(&llvm_config).arg("--version"));
cmd.arg("--llvm-version").arg(llvm_version);
if !build.is_rust_llvm(target) {
cmd.arg("--system-llvm");
}
cmd.args(&build.config.cmd.test_args());
@ -635,17 +629,32 @@ impl Step for Compiletest {
cmd.arg("--quiet");
}
// Only pass correct values for these flags for the `run-make` suite as it
// requires that a C++ compiler was configured which isn't always the case.
if suite == "run-make" {
let llvm_components = output(Command::new(&llvm_config).arg("--components"));
let llvm_cxxflags = output(Command::new(&llvm_config).arg("--cxxflags"));
cmd.arg("--cc").arg(build.cc(target))
.arg("--cxx").arg(build.cxx(target).unwrap())
.arg("--cflags").arg(build.cflags(target).join(" "))
.arg("--llvm-components").arg(llvm_components.trim())
.arg("--llvm-cxxflags").arg(llvm_cxxflags.trim());
} else {
if build.config.llvm_enabled {
let llvm_config = build.llvm_config(target);
let llvm_version = output(Command::new(&llvm_config).arg("--version"));
cmd.arg("--llvm-version").arg(llvm_version);
if !build.is_rust_llvm(target) {
cmd.arg("--system-llvm");
}
// Only pass correct values for these flags for the `run-make` suite as it
// requires that a C++ compiler was configured which isn't always the case.
if suite == "run-make" {
let llvm_components = output(Command::new(&llvm_config).arg("--components"));
let llvm_cxxflags = output(Command::new(&llvm_config).arg("--cxxflags"));
cmd.arg("--cc").arg(build.cc(target))
.arg("--cxx").arg(build.cxx(target).unwrap())
.arg("--cflags").arg(build.cflags(target).join(" "))
.arg("--llvm-components").arg(llvm_components.trim())
.arg("--llvm-cxxflags").arg(llvm_cxxflags.trim());
}
}
if suite == "run-make" && !build.config.llvm_enabled {
println!("Ignoring run-make test suite as they generally dont work without LLVM");
return;
}
if suite != "run-make" {
cmd.arg("--cc").arg("")
.arg("--cxx").arg("")
.arg("--cflags").arg("")

62
src/librustc_driver/driver.rs
View file

@ -8,6 +8,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![cfg_attr(not(feature="llvm"), allow(dead_code))]
use rustc::hir::{self, map as hir_map};
use rustc::hir::lowering::lower_crate;
use rustc::ich::Fingerprint;
@ -19,8 +21,6 @@ use rustc::session::config::{self, Input, OutputFilenames, OutputType};
use rustc::session::search_paths::PathKind;
use rustc::lint;
use rustc::middle::{self, stability, reachable};
#[cfg(feature="llvm")]
use rustc::middle::dependency_format;
use rustc::middle::privacy::AccessLevels;
use rustc::mir::transform::{MIR_CONST, MIR_VALIDATED, MIR_OPTIMIZED, Passes};
use rustc::ty::{self, TyCtxt, Resolutions, GlobalArenas};
@ -33,9 +33,7 @@ use rustc_incremental::{self, IncrementalHashesMap};
use rustc_resolve::{MakeGlobMap, Resolver};
use rustc_metadata::creader::CrateLoader;
use rustc_metadata::cstore::{self, CStore};
#[cfg(feature="llvm")]
use rustc_trans::back::{link, write};
#[cfg(feature="llvm")]
use rustc_trans::back::write;
use rustc_trans as trans;
use rustc_typeck as typeck;
use rustc_privacy;
@ -73,11 +71,7 @@ pub fn compile_input(sess: &Session,
output: &Option<PathBuf>,
addl_plugins: Option<Vec<String>>,
control: &CompileController) -> CompileResult {
#[cfg(feature="llvm")]
use rustc_trans::back::write::OngoingCrateTranslation;
#[cfg(not(feature="llvm"))]
type OngoingCrateTranslation = ();
macro_rules! controller_entry_point {
($point: ident, $tsess: expr, $make_state: expr, $phase_result: expr) => {{
let state = &mut $make_state;
@ -94,6 +88,23 @@ pub fn compile_input(sess: &Session,
}}
}
if cfg!(not(feature="llvm")) {
use rustc::session::config::CrateType;
if !sess.opts.debugging_opts.no_trans && sess.opts.output_types.should_trans() {
sess.err("LLVM is not supported by this rustc. Please use -Z no-trans to compile")
}
if sess.opts.crate_types.iter().all(|&t|{
t != CrateType::CrateTypeRlib && t != CrateType::CrateTypeExecutable
}) && !sess.opts.crate_types.is_empty() {
sess.err(
"LLVM is not supported by this rustc, so non rlib libraries are not supported"
);
}
sess.abort_if_errors();
}
// 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
@ -217,7 +228,6 @@ pub fn compile_input(sess: &Session,
tcx.print_debug_stats();
}
#[cfg(feature="llvm")]
let trans = phase_4_translate_to_llvm(tcx, analysis, incremental_hashes_map,
&outputs);
@ -233,24 +243,13 @@ pub fn compile_input(sess: &Session,
}
}
#[cfg(not(feature="llvm"))]
{
let _ = incremental_hashes_map;
sess.err(&format!("LLVM is not supported by this rustc"));
sess.abort_if_errors();
unreachable!();
}
#[cfg(feature="llvm")]
Ok((outputs, trans))
})??
};
#[cfg(not(feature="llvm"))]
{
let _ = outputs;
let _ = trans;
unreachable!();
if cfg!(not(feature="llvm")) {
let (_, _) = (outputs, trans);
sess.fatal("LLVM is not supported by this rustc");
}
#[cfg(feature="llvm")]
@ -393,7 +392,6 @@ pub struct CompileState<'a, 'tcx: 'a> {
pub resolutions: Option<&'a Resolutions>,
pub analysis: Option<&'a ty::CrateAnalysis>,
pub tcx: Option<TyCtxt<'a, 'tcx, 'tcx>>,
#[cfg(feature="llvm")]
pub trans: Option<&'a trans::CrateTranslation>,
}
@ -420,7 +418,6 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> {
resolutions: None,
analysis: None,
tcx: None,
#[cfg(feature="llvm")]
trans: None,
}
}
@ -509,7 +506,6 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> {
}
}
#[cfg(feature="llvm")]
fn state_after_llvm(input: &'a Input,
session: &'tcx Session,
out_dir: &'a Option<PathBuf>,
@ -523,7 +519,6 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> {
}
}
#[cfg(feature="llvm")]
fn state_when_compilation_done(input: &'a Input,
session: &'tcx Session,
out_dir: &'a Option<PathBuf>,
@ -942,7 +937,6 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
mir::provide(&mut local_providers);
reachable::provide(&mut local_providers);
rustc_privacy::provide(&mut local_providers);
#[cfg(feature="llvm")]
trans::provide(&mut local_providers);
typeck::provide(&mut local_providers);
ty::provide(&mut local_providers);
@ -955,7 +949,6 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
let mut extern_providers = ty::maps::Providers::default();
cstore::provide(&mut extern_providers);
#[cfg(feature="llvm")]
trans::provide(&mut extern_providers);
ty::provide_extern(&mut extern_providers);
traits::provide_extern(&mut extern_providers);
@ -1102,7 +1095,6 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session,
/// Run the translation phase to LLVM, after which the AST and analysis can
/// be discarded.
#[cfg(feature="llvm")]
pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
analysis: ty::CrateAnalysis,
incremental_hashes_map: IncrementalHashesMap,
@ -1112,7 +1104,7 @@ pub fn phase_4_translate_to_llvm<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
time(time_passes,
"resolving dependency formats",
|| dependency_format::calculate(tcx));
|| ::rustc::middle::dependency_format::calculate(tcx));
let translation =
time(time_passes,
@ -1147,9 +1139,9 @@ pub fn phase_5_run_llvm_passes(sess: &Session,
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.crate_name.as_str()));
time(sess.time_passes(), "linking", || {
::rustc_trans::back::link::link_binary(sess, trans, outputs, &trans.crate_name.as_str())
});
}
fn escape_dep_filename(filename: &str) -> String {

143
src/librustc_driver/lib.rs
View file

@ -28,15 +28,10 @@
#![feature(rustc_diagnostic_macros)]
#![feature(set_stdio)]
#[cfg(not(feature="llvm"))]
extern crate ar;
extern crate arena;
extern crate getopts;
extern crate graphviz;
extern crate env_logger;
#[cfg(not(feature="llvm"))]
extern crate owning_ref;
extern crate libc;
extern crate rustc;
extern crate rustc_allocator;
@ -71,8 +66,6 @@ use pretty::{PpMode, UserIdentifiedItem};
use rustc_resolve as resolve;
use rustc_save_analysis as save;
use rustc_save_analysis::DumpHandler;
#[cfg(feature="llvm")]
use rustc_trans::back::write::{RELOC_MODEL_ARGS, CODE_GEN_MODEL_ARGS};
use rustc::dep_graph::DepGraph;
use rustc::session::{self, config, Session, build_session, CompileResult};
use rustc::session::CompileIncomplete;
@ -81,13 +74,9 @@ use rustc::session::config::nightly_options;
use rustc::session::{early_error, early_warn};
use rustc::lint::Lint;
use rustc::lint;
#[cfg(not(feature="llvm"))]
use rustc::middle::cstore::MetadataLoader as MetadataLoaderTrait;
use rustc_metadata::locator;
use rustc_metadata::cstore::CStore;
use rustc::util::common::{time, ErrorReported};
#[cfg(not(feature="llvm"))]
use rustc_back::target::Target;
use serialize::json::ToJson;
@ -100,8 +89,6 @@ use std::ffi::OsString;
use std::io::{self, Read, Write};
use std::iter::repeat;
use std::path::PathBuf;
#[cfg(not(feature="llvm"))]
use std::path::Path;
use std::process::{self, Command, Stdio};
use std::rc::Rc;
use std::str;
@ -114,15 +101,11 @@ use syntax::feature_gate::{GatedCfg, UnstableFeatures};
use syntax::parse::{self, PResult};
use syntax_pos::{DUMMY_SP, MultiSpan};
#[cfg(not(feature="llvm"))]
use owning_ref::{OwningRef, ErasedBoxRef};
#[cfg(test)]
pub mod test;
pub mod driver;
pub mod pretty;
#[cfg(feature="llvm")]
pub mod target_features;
mod derive_registrar;
@ -169,48 +152,106 @@ pub fn run<F>(run_compiler: F) -> isize
}
#[cfg(not(feature="llvm"))]
pub struct NoLLvmMetadataLoader;
#[cfg(not(feature="llvm"))]
pub use NoLLvmMetadataLoader as MetadataLoader;
pub use no_llvm_metadata_loader::NoLLvmMetadataLoader as MetadataLoader;
#[cfg(feature="llvm")]
pub use rustc_trans::LlvmMetadataLoader as MetadataLoader;
#[cfg(not(feature="llvm"))]
impl MetadataLoaderTrait for NoLLvmMetadataLoader {
fn get_rlib_metadata(&self, _: &Target, filename: &Path) -> Result<ErasedBoxRef<[u8]>, String> {
use std::fs::File;
use std::io;
use self::ar::Archive;
mod no_llvm_metadata_loader {
extern crate ar;
extern crate owning_ref;
let file = File::open(filename).map_err(|e|format!("metadata file open err: {:?}", e))?;
let mut archive = Archive::new(file);
use rustc::middle::cstore::MetadataLoader as MetadataLoaderTrait;
use rustc_back::target::Target;
use std::io;
use std::fs::File;
use std::path::Path;
while let Some(entry_result) = archive.next_entry() {
let mut entry = entry_result.map_err(|e|format!("metadata section read err: {:?}", e))?;
if entry.header().identifier() == "rust.metadata.bin" {
let mut buf = Vec::new();
io::copy(&mut entry, &mut buf).unwrap();
let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
return Ok(buf.map_owner_box().erase_owner());
use self::ar::Archive;
use self::owning_ref::{OwningRef, ErasedBoxRef};
pub struct NoLLvmMetadataLoader;
impl MetadataLoaderTrait for NoLLvmMetadataLoader {
fn get_rlib_metadata(
&self,
_: &Target,
filename: &Path
) -> Result<ErasedBoxRef<[u8]>, String> {
let file = File::open(filename).map_err(|e| {
format!("metadata file open err: {:?}", e)
})?;
let mut archive = Archive::new(file);
while let Some(entry_result) = archive.next_entry() {
let mut entry = entry_result.map_err(|e| {
format!("metadata section read err: {:?}", e)
})?;
if entry.header().identifier() == "rust.metadata.bin" {
let mut buf = Vec::new();
io::copy(&mut entry, &mut buf).unwrap();
let buf: OwningRef<Vec<u8>, [u8]> = OwningRef::new(buf).into();
return Ok(buf.map_owner_box().erase_owner());
}
}
Err("Couldnt find metadata section".to_string())
}
Err("Couldnt find metadata section".to_string())
fn get_dylib_metadata(&self,
_target: &Target,
_filename: &Path)
-> Result<ErasedBoxRef<[u8]>, String> {
panic!("Dylib metadata loading not supported without LLVM")
}
}
}
#[cfg(not(feature="llvm"))]
mod rustc_trans {
use syntax_pos::symbol::Symbol;
use rustc::session::Session;
use rustc::session::config::{PrintRequest, OutputFilenames};
use rustc::ty::{TyCtxt, CrateAnalysis};
use rustc::ty::maps::Providers;
use rustc_incremental::IncrementalHashesMap;
use self::back::write::OngoingCrateTranslation;
pub fn init(_sess: &Session) {}
pub fn enable_llvm_debug() {}
pub fn provide(_providers: &mut Providers) {}
pub fn print_version() {}
pub fn print_passes() {}
pub fn print(_req: PrintRequest, _sess: &Session) {}
pub fn target_features(_sess: &Session) -> Vec<Symbol> { vec![] }
pub fn trans_crate<'a, 'tcx>(
_tcx: TyCtxt<'a, 'tcx, 'tcx>,
_analysis: CrateAnalysis,
_incr_hashes_map: IncrementalHashesMap,
_output_filenames: &OutputFilenames
) -> OngoingCrateTranslation {
OngoingCrateTranslation(())
}
fn get_dylib_metadata(&self,
_target: &Target,
_filename: &Path)
-> Result<ErasedBoxRef<[u8]>, String> {
panic!("Dylib metadata loading not supported without LLVM")
pub struct CrateTranslation(());
pub mod back {
pub mod write {
pub struct OngoingCrateTranslation(pub (in ::rustc_trans) ());
pub const RELOC_MODEL_ARGS: [(&'static str, ()); 0] = [];
pub const CODE_GEN_MODEL_ARGS: [(&'static str, ()); 0] = [];
}
}
__build_diagnostic_array! { librustc_trans, DIAGNOSTICS }
}
// Parse args and run the compiler. This is the primary entry point for rustc.
// See comments on CompilerCalls below for details about the callbacks argument.
// The FileLoader provides a way to load files from sources other than the file system.
#[cfg_attr(not(feature="llvm"), allow(unused_mut))]
pub fn run_compiler<'a>(args: &[String],
callbacks: &mut CompilerCalls<'a>,
file_loader: Option<Box<FileLoader + 'static>>,
@ -232,7 +273,6 @@ pub fn run_compiler<'a>(args: &[String],
let (sopts, cfg) = config::build_session_options_and_crate_config(&matches);
if sopts.debugging_opts.debug_llvm {
#[cfg(feature="llvm")]
rustc_trans::enable_llvm_debug();
}
@ -262,12 +302,10 @@ pub fn run_compiler<'a>(args: &[String],
let mut sess = session::build_session_with_codemap(
sopts, &dep_graph, input_file_path, descriptions, cstore.clone(), codemap, emitter_dest,
);
#[cfg(feature="llvm")]
rustc_trans::init(&sess);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
let mut cfg = config::build_configuration(&sess, cfg);
#[cfg(feature="llvm")]
target_features::add_configuration(&mut cfg, &sess);
sess.parse_sess.config = cfg;
@ -520,7 +558,6 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
Compilation::Continue
}
#[cfg_attr(not(feature="llvm"), allow(unused_mut))]
fn no_input(&mut self,
matches: &getopts::Matches,
sopts: &config::Options,
@ -544,11 +581,9 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls {
None,
descriptions.clone(),
cstore.clone());
#[cfg(feature="llvm")]
rustc_trans::init(&sess);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
let mut cfg = config::build_configuration(&sess, cfg.clone());
#[cfg(feature="llvm")]
target_features::add_configuration(&mut cfg, &sess);
sess.parse_sess.config = cfg;
let should_stop =
@ -802,25 +837,20 @@ impl RustcDefaultCalls {
}
PrintRequest::RelocationModels => {
println!("Available relocation models:");
#[cfg(feature="llvm")]
for &(name, _) in RELOC_MODEL_ARGS.iter() {
for &(name, _) in rustc_trans::back::write::RELOC_MODEL_ARGS.iter() {
println!(" {}", name);
}
println!("");
}
PrintRequest::CodeModels => {
println!("Available code models:");
#[cfg(feature="llvm")]
for &(name, _) in CODE_GEN_MODEL_ARGS.iter(){
for &(name, _) in rustc_trans::back::write::CODE_GEN_MODEL_ARGS.iter(){
println!(" {}", name);
}
println!("");
}
PrintRequest::TargetCPUs | PrintRequest::TargetFeatures => {
#[cfg(feature="llvm")]
rustc_trans::print(*req, sess);
#[cfg(not(feature="llvm"))]
panic!("LLVM not supported by this rustc")
}
}
}
@ -859,7 +889,6 @@ pub fn version(binary: &str, matches: &getopts::Matches) {
println!("commit-date: {}", unw(commit_date_str()));
println!("host: {}", config::host_triple());
println!("release: {}", unw(release_str()));
#[cfg(feature="llvm")]
rustc_trans::print_version();
}
}
@ -1157,7 +1186,6 @@ pub fn handle_options(args: &[String]) -> Option<getopts::Matches> {
}
if cg_flags.contains(&"passes=list".to_string()) {
#[cfg(feature="llvm")]
rustc_trans::print_passes();
return None;
}
@ -1285,7 +1313,6 @@ pub fn diagnostics_registry() -> errors::registry::Registry {
all_errors.extend_from_slice(&rustc_borrowck::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_resolve::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_privacy::DIAGNOSTICS);
#[cfg(feature="llvm")]
all_errors.extend_from_slice(&rustc_trans::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_const_eval::DIAGNOSTICS);
all_errors.extend_from_slice(&rustc_metadata::DIAGNOSTICS);

2
src/librustc_driver/test.rs
View file

@ -14,7 +14,6 @@ use driver;
use rustc::dep_graph::DepGraph;
use rustc_lint;
use rustc_resolve::MakeGlobMap;
#[cfg(feature="llvm")]
use rustc_trans;
use rustc::middle::lang_items;
use rustc::middle::free_region::FreeRegionMap;
@ -114,7 +113,6 @@ fn test_env<F>(source_string: &str,
diagnostic_handler,
Rc::new(CodeMap::new(FilePathMapping::empty())),
cstore.clone());
#[cfg(feature="llvm")]
rustc_trans::init(&sess);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
let input = config::Input::Str {

31
src/librustc_trans_utils/link.rs
View file

@ -8,34 +8,11 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use rustc::session::config::{self, /*NoDebugInfo,*/ OutputFilenames, Input, OutputType};
/*use rustc::session::filesearch;
use rustc::session::search_paths::PathKind;
*/use rustc::session::Session;
use rustc::middle::cstore;/*::{self, LinkMeta, NativeLibrary, LibSource, LinkagePreference,
NativeLibraryKind};*/
/*use rustc::middle::dependency_format::Linkage;
use rustc::util::common::time;
use rustc::util::fs::fix_windows_verbatim_for_gcc;
use rustc::dep_graph::{DepKind, DepNode};
use rustc::hir::def_id::CrateNum;
use rustc::hir::svh::Svh;
use rustc_back::tempdir::TempDir;
use rustc_back::{PanicStrategy, RelroLevel};
use rustc_incremental::IncrementalHashesMap;*/
/*use std::ascii;
use std::char;
use std::env;
use std::ffi::OsString;
use std::fs;
use std::io::{self, Read, Write};
use std::mem;
*/use std::path::PathBuf;/*{Path, PathBuf};
use std::process::Command;
use std::str;*/
use rustc::session::config::{self, OutputFilenames, Input, OutputType};
use rustc::session::Session;
use rustc::middle::cstore;
use std::path::PathBuf;
use syntax::ast;
//use syntax::attr;
use syntax_pos::Span;
pub fn find_crate_name(sess: Option<&Session>,