Remove some more cfg's
diff --git a/src/bootstrap/check.rs b/src/bootstrap/check.rs
index c65f5a9..95ac71d 100644
--- a/src/bootstrap/check.rs
+++ b/src/bootstrap/check.rs
@@ -618,12 +618,6 @@
         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.flags.cmd.test_args());
 
@@ -635,17 +629,32 @@
             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");
+            return;
+        }
+
+        if suite != "run-make" {
             cmd.arg("--cc").arg("")
                .arg("--cxx").arg("")
                .arg("--cflags").arg("")
diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs
index c3de39f..82ced4d 100644
--- a/src/librustc_driver/driver.rs
+++ b/src/librustc_driver/driver.rs
@@ -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::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_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,8 +71,6 @@
                      output: &Option<PathBuf>,
                      addl_plugins: Option<Vec<String>>,
                      control: &CompileController) -> CompileResult {
-    use rustc_trans::back::write::OngoingCrateTranslation;
-
     macro_rules! controller_entry_point {
         ($point: ident, $tsess: expr, $make_state: expr, $phase_result: expr) => {{
             let state = &mut $make_state;
@@ -91,10 +87,27 @@
         }}
     }
 
+    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.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
-    let (outputs, trans): (OutputFilenames, OngoingCrateTranslation) = {
+    let (outputs, trans): (OutputFilenames, write::OngoingCrateTranslation) = {
         let krate = match phase_1_parse_input(control, sess, input) {
             Ok(krate) => krate,
             Err(mut parse_error) => {
@@ -214,7 +227,6 @@
                 tcx.print_debug_stats();
             }
 
-            #[cfg(feature="llvm")]
             let trans = phase_4_translate_to_llvm(tcx, analysis, incremental_hashes_map,
                                                   &outputs);
 
@@ -230,24 +242,14 @@
                 }
             }
 
-            #[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!();
+        let (_, _) = (outputs, trans);
+        sess.fatal("LLVM is not supported by this rustc");
     }
 
     #[cfg(feature="llvm")]
@@ -504,7 +506,6 @@
         }
     }
 
-    #[cfg(feature="llvm")]
     fn state_after_llvm(input: &'a Input,
                         session: &'tcx Session,
                         out_dir: &'a Option<PathBuf>,
@@ -518,7 +519,6 @@
         }
     }
 
-    #[cfg(feature="llvm")]
     fn state_when_compilation_done(input: &'a Input,
                                    session: &'tcx Session,
                                    out_dir: &'a Option<PathBuf>,
@@ -1095,7 +1095,6 @@
 
 /// 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,
@@ -1105,7 +1104,7 @@
 
     time(time_passes,
          "resolving dependency formats",
-         || dependency_format::calculate(tcx));
+         || ::rustc::middle::dependency_format::calculate(tcx));
 
     let translation =
         time(time_passes,
@@ -1140,9 +1139,9 @@
 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 {
diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs
index ea7af4e..4fc4b8d 100644
--- a/src/librustc_driver/lib.rs
+++ b/src/librustc_driver/lib.rs
@@ -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;
@@ -79,13 +74,9 @@
 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;
 
@@ -98,8 +89,6 @@
 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;
@@ -112,15 +101,11 @@
 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;
 
@@ -167,67 +152,98 @@
 }
 
 #[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;
+    
+    use rustc::middle::cstore::MetadataLoader as MetadataLoaderTrait;
+    use rustc_back::target::Target;
+    use std::io;
+    use std::fs::File;
+    use std::path::Path;
+    
+    use self::ar::Archive;
+    use self::owning_ref::{OwningRef, ErasedBoxRef};
 
-        let file = File::open(filename).map_err(|e|format!("metadata file open err: {:?}", e))?;
-        let mut archive = Archive::new(file);
+    pub struct NoLLvmMetadataLoader;
 
-        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());
+    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")
+        fn get_dylib_metadata(&self,
+                            _target: &Target,
+                            _filename: &Path)
+                            -> Result<ErasedBoxRef<[u8]>, String> {
+            panic!("Dylib metadata loading not supported without LLVM")
+        }
     }
 }
 
-#[cfg(feature="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 struct CrateTranslation(());
-    pub mod back {
-        pub mod write {
-            pub struct OngoingCrateTranslation(());
-        }
-    }
-    mod diagnostics {
-        register_long_diagnostics! {}
+    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(())
     }
 
-    pub use diagnostics::DIAGNOSTICS;
+    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>>,
@@ -282,7 +298,6 @@
     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;
 
@@ -535,7 +550,6 @@
         Compilation::Continue
     }
 
-    #[cfg_attr(not(feature="llvm"), allow(unused_mut))]
     fn no_input(&mut self,
                 matches: &getopts::Matches,
                 sopts: &config::Options,
@@ -562,7 +576,6 @@
                 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 =
@@ -816,7 +829,6 @@
                 }
                 PrintRequest::RelocationModels => {
                     println!("Available relocation models:");
-                    #[cfg(feature="llvm")]
                     for &(name, _) in rustc_trans::back::write::RELOC_MODEL_ARGS.iter() {
                         println!("    {}", name);
                     }
@@ -824,17 +836,13 @@
                 }
                 PrintRequest::CodeModels => {
                     println!("Available code models:");
-                    #[cfg(feature="llvm")]
                     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")
                 }
             }
         }
@@ -873,7 +881,6 @@
         println!("commit-date: {}", unw(commit_date_str()));
         println!("host: {}", config::host_triple());
         println!("release: {}", unw(release_str()));
-        #[cfg(feature="llvm")]
         rustc_trans::print_version();
     }
 }
@@ -1171,7 +1178,6 @@
     }
 
     if cg_flags.contains(&"passes=list".to_string()) {
-        #[cfg(feature="llvm")]
         rustc_trans::print_passes();
         return None;
     }
diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs
index f3f934c..b187cda 100644
--- a/src/librustc_driver/test.rs
+++ b/src/librustc_driver/test.rs
@@ -14,7 +14,6 @@
 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;