Feat: update nightly to 2021-12-04 in anticipation for 0.2

Author: RDambrosio016

crates/cuda_std/src/lib.rs

@@ -24,7 +24,13 @@
 #![cfg_attr(
     target_os = "cuda",
     no_std,
-    feature(register_attr, alloc_error_handler, asm, link_llvm_intrinsics),
+    feature(
+        register_attr,
+        alloc_error_handler,
+        asm,
+        asm_experimental_arch,
+        link_llvm_intrinsics
+    ),
     register_attr(nvvm_internal)
 )]
 

crates/rustc_codegen_nvvm/src/abi.rs

@@ -220,15 +220,7 @@ impl LlvmType for CastTarget {
         let mut args: Vec<_> = self
             .prefix
             .iter()
-            .flat_map(|option_kind| {
-                option_kind.map(|kind| {
-                    Reg {
-                        kind,
-                        size: self.prefix_chunk_size,
-                    }
-                    .llvm_type(cx)
-                })
-            })
+            .flat_map(|option_reg| option_reg.map(|reg| reg.llvm_type(cx)))
             .chain((0..rest_count).map(|_| rest_ll_unit))
             .collect();
 
@@ -538,16 +530,18 @@ impl<'a, 'll, 'tcx> AbiBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         fn_abi.apply_attrs_callsite(self, callsite)
     }
 
-    fn get_param(&self, index: usize) -> Self::Value {
+    fn get_param(&mut self, index: usize) -> Self::Value {
         let val = llvm::get_param(self.llfn(), index as c_uint);
         trace!("Get param `{:?}`", val);
         unsafe {
             let llfnty = LLVMRustGetFunctionType(self.llfn());
-            let map = self.remapped_integer_args.borrow();
+            // destructure so rustc doesnt complain in the call to transmute_llval
+            let Self { cx, llbuilder } = self;
+            let map = cx.remapped_integer_args.borrow();
             if let Some((_, key)) = map.get(llfnty) {
                 if let Some((_, new_ty)) = key.iter().find(|t| t.0 == index) {
                     trace!("Casting irregular param {:?} to {:?}", val, new_ty);
-                    return transmute_llval(*self.llbuilder.lock().unwrap(), self.cx, val, *new_ty);
+                    return transmute_llval(llbuilder, cx, val, *new_ty);
                 }
             }
             val

crates/rustc_codegen_nvvm/src/asm.rs

@@ -14,7 +14,7 @@ use rustc_codegen_ssa::{
 };
 use rustc_hash::FxHashMap;
 use rustc_hir::LlvmInlineAsmInner;
-use rustc_middle::span_bug;
+use rustc_middle::{span_bug, ty::Instance};
 use rustc_span::{Pos, Span};
 use rustc_target::asm::{InlineAsmRegClass, InlineAsmRegOrRegClass, NvptxInlineAsmRegClass};
 
@@ -118,6 +118,7 @@ impl<'a, 'll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         operands: &[InlineAsmOperandRef<'tcx, Self>],
         options: rustc_ast::InlineAsmOptions,
         line_spans: &[Span],
+        _inst: Instance,
     ) {
         // Collect the types of output operands
         let mut constraints = vec![];

crates/rustc_codegen_nvvm/src/back.rs

@@ -246,7 +246,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
         tcx,
         cgu_name,
         module_codegen,
-        dep_graph::hash_result,
+        Some(dep_graph::hash_result),
     );
 
     fn module_codegen(tcx: TyCtxt<'_>, cgu_name: Symbol) -> ModuleCodegen<LlvmMod> {

crates/rustc_codegen_nvvm/src/builder.rs

@@ -139,7 +139,7 @@ impl<'a, 'll, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'll, 'tcx> {
     fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation) {
         unsafe {
             let dbg_loc_as_llval = llvm::LLVMRustMetadataAsValue(self.cx().llcx, dbg_loc);
-            llvm::LLVMSetCurrentDebugLocation(*self.llbuilder.lock().unwrap(), dbg_loc_as_llval);
+            llvm::LLVMSetCurrentDebugLocation(self.llbuilder, dbg_loc_as_llval);
         }
     }
 
@@ -256,7 +256,7 @@ impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
         type_names::push_item_name(self.tcx(), def_id, false, &mut name);
 
         // Find the enclosing function, in case this is a closure.
-        let enclosing_fn_def_id = self.tcx().closure_base_def_id(def_id);
+        let enclosing_fn_def_id = self.tcx().typeck_root_def_id(def_id);
 
         // Get_template_parameters() will append a `<...>` clause to the function
         // name if necessary.

crates/rustc_codegen_nvvm/src/debug_info/mod.rs

@@ -466,10 +466,9 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
         )
     }
 
-    fn sideeffect(&mut self) {
-        trace!("Generate sideeffect call");
-        let fnname = self.get_intrinsic("llvm.sideeffect");
-        self.call(self.type_i1(), fnname, &[], None);
+    fn type_test(&mut self, _pointer: Self::Value, _typeid: Self::Value) -> Self::Value {
+        // LLVM CFI doesnt make sense on the GPU
+        self.const_i32(0)
     }
 
     fn va_start(&mut self, va_list: &'ll Value) -> Self::Value {

crates/rustc_codegen_nvvm/src/intrinsic.rs

@@ -110,7 +110,7 @@ impl CodegenBackend for NvvmCodegenBackend {
             Ok(readjust_fn_abi(tcx, result?))
         };
     }
-    fn provide_extern(&self, _providers: &mut query::Providers) {}
+    fn provide_extern(&self, _providers: &mut query::ExternProviders) {}
 
     fn codegen_crate(
         &self,

crates/rustc_codegen_nvvm/src/lib.rs

@@ -414,11 +414,15 @@ extern "C" {
     pub(crate) type ThinLTOData;
 }
 
+unsafe impl Send for ThinLTOData {}
+
 /// LLVMRustThinLTOBuffer
 extern "C" {
     pub(crate) type ThinLTOBuffer;
 }
 
+unsafe impl Send for ThinLTOBuffer {}
+
 /// LLVMRustThinLTOModule
 #[repr(C)]
 pub(crate) struct ThinLTOModule {
@@ -443,6 +447,9 @@ extern "C" {
 extern "C" {
     pub type Context;
 }
+
+unsafe impl Send for Context {}
+
 extern "C" {
     pub(crate) type Type;
 }
@@ -468,6 +475,9 @@ pub(crate) struct OperandBundleDef<'a>(InvariantOpaque<'a>);
 extern "C" {
     pub(crate) type ModuleBuffer;
 }
+
+unsafe impl Send for ModuleBuffer {}
+
 #[repr(C)]
 pub struct PassManager<'a>(InvariantOpaque<'a>);
 extern "C" {

crates/rustc_codegen_nvvm/src/llvm.rs

@@ -5,5 +5,5 @@
 # to the user in the error, instead of "error: invalid channel name '[toolchain]'".
 
 [toolchain]
-channel = "nightly-2021-10-18"
+channel = "nightly-2021-12-04"
 components = ["rust-src", "rustc-dev", "llvm-tools-preview"]