Run cargo fmt

Author: jorge-ortega

crates/cuda_std/src/lib.rs

@@ -24,7 +24,7 @@
 #![allow(internal_features)]
 #![cfg_attr(
     target_os = "cuda",
-    feature(alloc_error_handler, asm_experimental_arch, link_llvm_intrinsics),
+    feature(alloc_error_handler, asm_experimental_arch, link_llvm_intrinsics)
 )]
 
 extern crate alloc;

crates/optix/examples/ex02_pipeline/device/src/lib.rs

@@ -1,9 +1,5 @@
 #![feature(asm)]
-#![cfg_attr(
-    target_os = "cuda",
-    no_std,
-    register_attr(nvvm_internal)
-)]
+#![cfg_attr(target_os = "cuda", no_std, register_attr(nvvm_internal))]
 // #![deny(warnings)]
 #![allow(clippy::missing_safety_doc)]
 

crates/rustc_codegen_nvvm/src/abi.rs

@@ -207,9 +207,16 @@ impl LlvmType for CastTarget {
                 self.rest.total
             );
             if self.rest.total.bytes() % self.rest.unit.size.bytes() != 0 {
-                assert_eq!(self.rest.unit.kind, RegKind::Integer, "only int regs can be split");
+                assert_eq!(
+                    self.rest.unit.kind,
+                    RegKind::Integer,
+                    "only int regs can be split"
+                );
             }
-            self.rest.total.bytes().div_ceil(self.rest.unit.size.bytes())
+            self.rest
+                .total
+                .bytes()
+                .div_ceil(self.rest.unit.size.bytes())
         };
 
         // Simplify to a single unit or an array if there's no prefix.
@@ -226,8 +233,10 @@ impl LlvmType for CastTarget {
         }
 
         // Generate a struct type with the prefix and the "rest" arguments.
-        let prefix_args =
-            self.prefix.iter().flat_map(|option_reg| option_reg.map(|reg| reg.llvm_type(cx)));
+        let prefix_args = self
+            .prefix
+            .iter()
+            .flat_map(|option_reg| option_reg.map(|reg| reg.llvm_type(cx)));
         let rest_args = (0..rest_count).map(|_| rest_ll_unit);
         let args: Vec<_> = prefix_args.chain(rest_args).collect();
         cx.type_struct(&args, false)
@@ -597,8 +606,7 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                 on_stack: _,
             } => {
                 let align = attrs.pointee_align.unwrap_or(self.layout.align.abi);
-                OperandValue::Ref(PlaceValue::new_sized(val, align))
-                    .store(bx, dst);
+                OperandValue::Ref(PlaceValue::new_sized(val, align)).store(bx, dst);
             }
             // Unsized indirect arguments
             PassMode::Indirect {
@@ -642,7 +650,9 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                 trace!("store cast end");
             }
             _ => {
-                OperandRef::from_immediate_or_packed_pair(bx, val, self.layout).val.store(bx, dst);
+                OperandRef::from_immediate_or_packed_pair(bx, val, self.layout)
+                    .val
+                    .store(bx, dst);
             }
         }
     }
@@ -676,7 +686,11 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                 OperandValue::Ref(place_val).store(bx, dst);
             }
             PassMode::Direct(_)
-            | PassMode::Indirect { attrs: _, meta_attrs: None, on_stack: _, }
+            | PassMode::Indirect {
+                attrs: _,
+                meta_attrs: None,
+                on_stack: _,
+            }
             | PassMode::Cast { .. } => {
                 let next_arg = next();
                 self.store(bx, next_arg, dst);

crates/rustc_codegen_nvvm/src/allocator.rs

@@ -48,12 +48,14 @@ pub(crate) unsafe fn codegen(
                 }
             };
 
-            let ty = unsafe { llvm::LLVMFunctionType(
-                output.unwrap_or(void),
-                args.as_ptr(),
-                args.len() as c_uint,
-                False,
-            ) };
+            let ty = unsafe {
+                llvm::LLVMFunctionType(
+                    output.unwrap_or(void),
+                    args.as_ptr(),
+                    args.len() as c_uint,
+                    False,
+                )
+            };
             let name = format!("__rust_{}", method.name);
             let llfn = unsafe {
                 llvm::LLVMRustGetOrInsertFunction(llmod, name.as_ptr().cast(), name.len(), ty)
@@ -68,7 +70,9 @@ pub(crate) unsafe fn codegen(
             };
             unsafe { llvm::LLVMRustSetVisibility(callee, llvm::Visibility::Hidden) };
 
-            let llbb = unsafe { llvm::LLVMAppendBasicBlockInContext(llcx, llfn, "entry\0".as_ptr().cast()) };
+            let llbb = unsafe {
+                llvm::LLVMAppendBasicBlockInContext(llcx, llfn, "entry\0".as_ptr().cast())
+            };
 
             let llbuilder = unsafe { llvm::LLVMCreateBuilderInContext(llcx) };
             unsafe { llvm::LLVMPositionBuilderAtEnd(llbuilder, llbb) };
@@ -77,13 +81,15 @@ pub(crate) unsafe fn codegen(
                 .enumerate()
                 .map(|(i, _)| unsafe { llvm::LLVMGetParam(llfn, i as c_uint) })
                 .collect::<Vec<_>>();
-            let ret = unsafe { llvm::LLVMRustBuildCall(
-                llbuilder,
-                callee,
-                args.as_ptr(),
-                args.len() as c_uint,
-                None,
-            ) };
+            let ret = unsafe {
+                llvm::LLVMRustBuildCall(
+                    llbuilder,
+                    callee,
+                    args.as_ptr(),
+                    args.len() as c_uint,
+                    None,
+                )
+            };
             unsafe { llvm::LLVMSetTailCall(ret, True) };
             if output.is_some() {
                 unsafe { llvm::LLVMBuildRet(llbuilder, ret) };

crates/rustc_codegen_nvvm/src/back.rs

@@ -194,8 +194,9 @@ pub(crate) unsafe fn codegen(
             .temp_path(OutputType::LlvmAssembly, module_name);
         let out = out.to_str().unwrap();
 
-        let result =
-            unsafe { llvm::LLVMRustPrintModule(llmod, out.as_c_char_ptr(), out.len(), demangle_callback) };
+        let result = unsafe {
+            llvm::LLVMRustPrintModule(llmod, out.as_c_char_ptr(), out.len(), demangle_callback)
+        };
 
         result.into_result().map_err(|()| {
             let msg = format!("failed to write NVVM IR to {}", out);
@@ -350,56 +351,59 @@ pub(crate) unsafe fn optimize(
 
     let tm = (cgcx.tm_factory)(tm_factory_config).expect("failed to create target machine");
 
-    if config.opt_level.is_some() { unsafe {
-        let fpm = llvm::LLVMCreateFunctionPassManagerForModule(llmod);
-        let mpm = llvm::LLVMCreatePassManager();
+    if config.opt_level.is_some() {
+        unsafe {
+            let fpm = llvm::LLVMCreateFunctionPassManagerForModule(llmod);
+            let mpm = llvm::LLVMCreatePassManager();
 
-        let addpass = |pass_name: &str| {
-            let pass = llvm::LLVMRustFindAndCreatePass(pass_name.as_c_char_ptr(), pass_name.len());
-            if pass.is_none() {
-                return false;
-            }
-            let pass = pass.unwrap();
-            let pass_manager = match llvm::LLVMRustPassKind(pass) {
-                llvm::PassKind::Function => &fpm,
-                llvm::PassKind::Module => &mpm,
-                llvm::PassKind::Other => {
-                    diag_handler.err("Encountered LLVM pass kind we can't handle");
-                    return true;
+            let addpass = |pass_name: &str| {
+                let pass =
+                    llvm::LLVMRustFindAndCreatePass(pass_name.as_c_char_ptr(), pass_name.len());
+                if pass.is_none() {
+                    return false;
                 }
+                let pass = pass.unwrap();
+                let pass_manager = match llvm::LLVMRustPassKind(pass) {
+                    llvm::PassKind::Function => &fpm,
+                    llvm::PassKind::Module => &mpm,
+                    llvm::PassKind::Other => {
+                        diag_handler.err("Encountered LLVM pass kind we can't handle");
+                        return true;
+                    }
+                };
+                llvm::LLVMRustAddPass(pass_manager, pass);
+                true
             };
-            llvm::LLVMRustAddPass(pass_manager, pass);
-            true
-        };
 
-        if !config.no_prepopulate_passes {
-            llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
-            llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
-            let opt_level = config
-                .opt_level
-                .map_or(llvm::CodeGenOptLevel::None, |x| to_llvm_opt_settings(x).0);
-            with_llvm_pmb(llmod, config, opt_level, &mut |b| {
-                llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(b, fpm);
-                llvm::LLVMPassManagerBuilderPopulateModulePassManager(b, mpm);
-            })
-        }
+            if !config.no_prepopulate_passes {
+                llvm::LLVMRustAddAnalysisPasses(tm, fpm, llmod);
+                llvm::LLVMRustAddAnalysisPasses(tm, mpm, llmod);
+                let opt_level = config
+                    .opt_level
+                    .map_or(llvm::CodeGenOptLevel::None, |x| to_llvm_opt_settings(x).0);
+                with_llvm_pmb(llmod, config, opt_level, &mut |b| {
+                    llvm::LLVMPassManagerBuilderPopulateFunctionPassManager(b, fpm);
+                    llvm::LLVMPassManagerBuilderPopulateModulePassManager(b, mpm);
+                })
+            }
 
-        for pass in &config.passes {
-            if !addpass(pass) {
-                diag_handler.warn(format!("unknown pass `{}`, ignoring", pass));
+            for pass in &config.passes {
+                if !addpass(pass) {
+                    diag_handler.warn(format!("unknown pass `{}`, ignoring", pass));
+                }
             }
-        }
 
-        diag_handler.abort_if_errors();
+            diag_handler.abort_if_errors();
 
-        // Finally, run the actual optimization passes
-        llvm::LLVMRustRunFunctionPassManager(fpm, llmod);
-        llvm::LLVMRunPassManager(mpm, llmod);
+            // Finally, run the actual optimization passes
+            llvm::LLVMRustRunFunctionPassManager(fpm, llmod);
+            llvm::LLVMRunPassManager(mpm, llmod);
 
-        // Deallocate managers that we're now done with
-        llvm::LLVMDisposePassManager(fpm);
-        llvm::LLVMDisposePassManager(mpm);
-    } }
+            // Deallocate managers that we're now done with
+            llvm::LLVMDisposePassManager(fpm);
+            llvm::LLVMDisposePassManager(mpm);
+        }
+    }
 
     Ok(())
 }
@@ -409,61 +413,63 @@ unsafe fn with_llvm_pmb(
     config: &ModuleConfig,
     opt_level: llvm::CodeGenOptLevel,
     f: &mut impl FnMut(&llvm::PassManagerBuilder),
-) { unsafe {
-    use std::ptr;
-
-    let builder = llvm::LLVMPassManagerBuilderCreate();
-    let opt_size = config
-        .opt_size
-        .map_or(llvm::CodeGenOptSizeNone, |x| to_llvm_opt_settings(x).1);
-
-    llvm::LLVMRustConfigurePassManagerBuilder(
-        builder,
-        opt_level,
-        config.merge_functions,
-        config.vectorize_slp,
-        config.vectorize_loop,
-        false,
-        ptr::null(),
-        ptr::null(),
-    );
-
-    llvm::LLVMPassManagerBuilderSetSizeLevel(builder, opt_size as u32);
-
-    if opt_size != llvm::CodeGenOptSizeNone {
-        llvm::LLVMPassManagerBuilderSetDisableUnrollLoops(builder, 1);
-    }
+) {
+    unsafe {
+        use std::ptr;
+
+        let builder = llvm::LLVMPassManagerBuilderCreate();
+        let opt_size = config
+            .opt_size
+            .map_or(llvm::CodeGenOptSizeNone, |x| to_llvm_opt_settings(x).1);
+
+        llvm::LLVMRustConfigurePassManagerBuilder(
+            builder,
+            opt_level,
+            config.merge_functions,
+            config.vectorize_slp,
+            config.vectorize_loop,
+            false,
+            ptr::null(),
+            ptr::null(),
+        );
+
+        llvm::LLVMPassManagerBuilderSetSizeLevel(builder, opt_size as u32);
+
+        if opt_size != llvm::CodeGenOptSizeNone {
+            llvm::LLVMPassManagerBuilderSetDisableUnrollLoops(builder, 1);
+        }
 
-    llvm::LLVMRustAddBuilderLibraryInfo(builder, llmod, config.no_builtins);
+        llvm::LLVMRustAddBuilderLibraryInfo(builder, llmod, config.no_builtins);
 
-    // Here we match what clang does (kinda). For O0 we only inline
-    // always-inline functions (but don't add lifetime intrinsics), at O1 we
-    // inline with lifetime intrinsics, and O2+ we add an inliner with a
-    // thresholds copied from clang.
-    match (opt_level, opt_size) {
-        (llvm::CodeGenOptLevel::Aggressive, ..) => {
-            llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 275);
-        }
-        (_, llvm::CodeGenOptSizeDefault) => {
-            llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 75);
-        }
-        (_, llvm::CodeGenOptSizeAggressive) => {
-            llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 25);
-        }
-        (llvm::CodeGenOptLevel::None, ..) => {
-            llvm::LLVMRustAddAlwaysInlinePass(builder, false);
-        }
-        (llvm::CodeGenOptLevel::Less, ..) => {
-            llvm::LLVMRustAddAlwaysInlinePass(builder, true);
-        }
-        (llvm::CodeGenOptLevel::Default, ..) => {
-            llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 225);
-        }
-        (llvm::CodeGenOptLevel::Other, ..) => {
-            bug!("CodeGenOptLevel::Other selected")
+        // Here we match what clang does (kinda). For O0 we only inline
+        // always-inline functions (but don't add lifetime intrinsics), at O1 we
+        // inline with lifetime intrinsics, and O2+ we add an inliner with a
+        // thresholds copied from clang.
+        match (opt_level, opt_size) {
+            (llvm::CodeGenOptLevel::Aggressive, ..) => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 275);
+            }
+            (_, llvm::CodeGenOptSizeDefault) => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 75);
+            }
+            (_, llvm::CodeGenOptSizeAggressive) => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 25);
+            }
+            (llvm::CodeGenOptLevel::None, ..) => {
+                llvm::LLVMRustAddAlwaysInlinePass(builder, false);
+            }
+            (llvm::CodeGenOptLevel::Less, ..) => {
+                llvm::LLVMRustAddAlwaysInlinePass(builder, true);
+            }
+            (llvm::CodeGenOptLevel::Default, ..) => {
+                llvm::LLVMPassManagerBuilderUseInlinerWithThreshold(builder, 225);
+            }
+            (llvm::CodeGenOptLevel::Other, ..) => {
+                bug!("CodeGenOptLevel::Other selected")
+            }
         }
-    }
 
-    f(builder);
-    llvm::LLVMPassManagerBuilderDispose(builder);
-}}
+        f(builder);
+        llvm::LLVMPassManagerBuilderDispose(builder);
+    }
+}