1 files changed, 20 insertions, 35 deletions

diff --git a/src/librustc_codegen_llvm/base.rs b/src/librustc_codegen_llvm/base.rs
index edd34b52ead..4168d2b66e4 100644
--- a/src/librustc_codegen_llvm/base.rs
+++ b/src/librustc_codegen_llvm/base.rs
@@ -14,30 +14,30 @@
 //!   int)` and `rec(x=int, y=int, z=int)` will have the same `llvm::Type`.
 
 use super::{LlvmCodegenBackend, ModuleLlvm};
-use rustc_codegen_ssa::{ModuleCodegen, ModuleKind};
 use rustc_codegen_ssa::base::maybe_create_entry_wrapper;
+use rustc_codegen_ssa::{ModuleCodegen, ModuleKind};
 
-use crate::llvm;
-use crate::metadata;
 use crate::builder::Builder;
 use crate::common;
 use crate::context::CodegenCx;
+use crate::llvm;
+use crate::metadata;
 use rustc::dep_graph;
-use rustc::mir::mono::{Linkage, Visibility};
-use rustc::middle::cstore::{EncodedMetadata};
-use rustc::ty::TyCtxt;
+use rustc::middle::cstore::EncodedMetadata;
 use rustc::middle::exported_symbols;
+use rustc::mir::mono::{Linkage, Visibility};
 use rustc::session::config::DebugInfo;
+use rustc::ty::TyCtxt;
 use rustc_codegen_ssa::mono_item::MonoItemExt;
 use rustc_data_structures::small_c_str::SmallCStr;
 
-use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::back::write::submit_codegened_module_to_llvm;
+use rustc_codegen_ssa::traits::*;
 
+use rustc::hir::CodegenFnAttrs;
 use std::ffi::CString;
 use std::time::Instant;
 use syntax_pos::symbol::Symbol;
-use rustc::hir::CodegenFnAttrs;
 
 use crate::value::Value;
 
@@ -46,22 +46,22 @@ pub fn write_compressed_metadata<'tcx>(
     metadata: &EncodedMetadata,
     llvm_module: &mut ModuleLlvm,
 ) {
-    use std::io::Write;
-    use flate2::Compression;
     use flate2::write::DeflateEncoder;
+    use flate2::Compression;
+    use std::io::Write;
 
     let (metadata_llcx, metadata_llmod) = (&*llvm_module.llcx, llvm_module.llmod());
     let mut compressed = tcx.metadata_encoding_version();
     DeflateEncoder::new(&mut compressed, Compression::fast())
-        .write_all(&metadata.raw_data).unwrap();
+        .write_all(&metadata.raw_data)
+        .unwrap();
 
     let llmeta = common::bytes_in_context(metadata_llcx, &compressed);
     let llconst = common::struct_in_context(metadata_llcx, &[llmeta], false);
     let name = exported_symbols::metadata_symbol_name(tcx);
     let buf = CString::new(name).unwrap();
-    let llglobal = unsafe {
-        llvm::LLVMAddGlobal(metadata_llmod, common::val_ty(llconst), buf.as_ptr())
-    };
+    let llglobal =
+        unsafe { llvm::LLVMAddGlobal(metadata_llmod, common::val_ty(llconst), buf.as_ptr()) };
     unsafe {
         llvm::LLVMSetInitializer(llglobal, llconst);
         let section_name = metadata::metadata_section_name(&tcx.sess.target.target);
@@ -95,12 +95,7 @@ impl Iterator for ValueIter<'ll> {
 }
 
 pub fn iter_globals(llmod: &'ll llvm::Module) -> ValueIter<'ll> {
-    unsafe {
-        ValueIter {
-            cur: llvm::LLVMGetFirstGlobal(llmod),
-            step: llvm::LLVMGetNextGlobal,
-        }
-    }
+    unsafe { ValueIter { cur: llvm::LLVMGetFirstGlobal(llmod), step: llvm::LLVMGetNextGlobal } }
 }
 
 pub fn compile_codegen_unit(
@@ -112,34 +107,24 @@ pub fn compile_codegen_unit(
     let start_time = Instant::now();
 
     let dep_node = tcx.codegen_unit(cgu_name).codegen_dep_node(tcx);
-    let (module, _) = tcx.dep_graph.with_task(
-        dep_node,
-        tcx,
-        cgu_name,
-        module_codegen,
-        dep_graph::hash_result,
-    );
+    let (module, _) =
+        tcx.dep_graph.with_task(dep_node, tcx, cgu_name, module_codegen, dep_graph::hash_result);
     let time_to_codegen = start_time.elapsed();
     drop(prof_timer);
 
     // We assume that the cost to run LLVM on a CGU is proportional to
     // the time we needed for codegenning it.
-    let cost = time_to_codegen.as_secs() * 1_000_000_000 +
-               time_to_codegen.subsec_nanos() as u64;
+    let cost = time_to_codegen.as_secs() * 1_000_000_000 + time_to_codegen.subsec_nanos() as u64;
 
     submit_codegened_module_to_llvm(&LlvmCodegenBackend(()), tx_to_llvm_workers, module, cost);
 
-    fn module_codegen(
-        tcx: TyCtxt<'_>,
-        cgu_name: Symbol,
-    ) -> ModuleCodegen<ModuleLlvm> {
+    fn module_codegen(tcx: TyCtxt<'_>, cgu_name: Symbol) -> ModuleCodegen<ModuleLlvm> {
         let cgu = tcx.codegen_unit(cgu_name);
         // Instantiate monomorphizations without filling out definitions yet...
         let llvm_module = ModuleLlvm::new(tcx, &cgu_name.as_str());
         {
             let cx = CodegenCx::new(tcx, cgu, &llvm_module);
-            let mono_items = cx.codegen_unit
-                               .items_in_deterministic_order(cx.tcx);
+            let mono_items = cx.codegen_unit.items_in_deterministic_order(cx.tcx);
             for &(mono_item, (linkage, visibility)) in &mono_items {
                 mono_item.predefine::<Builder<'_, '_, '_>>(&cx, linkage, visibility);
             }