save work

Author: ZelboK

crates/rustc_codegen_nvvm/src/asm.rs

@@ -302,6 +302,7 @@ pub(crate) fn inline_asm_call<'a, 'll, 'tcx>(
                 dia,
             );
             let call = bx.call(fty,
+                None,
                  None,
                   v,
                    inputs, None);

crates/rustc_codegen_nvvm/src/back.rs

@@ -13,7 +13,7 @@ use rustc_codegen_ssa::{
     CompiledModule, ModuleCodegen, ModuleKind,
 };
 use rustc_data_structures::small_c_str::SmallCStr;
-use rustc_errors::{FatalError, Handler, DiagnosticMessage, DiagnosticBuilder};
+use rustc_errors::{FatalError, Handler};
 use rustc_fs_util::path_to_c_string;
 use rustc_middle::bug;
 use rustc_middle::mir::mono::MonoItem;

crates/rustc_codegen_nvvm/src/builder.rs

@@ -12,6 +12,7 @@ use rustc_codegen_ssa::traits::BackendTypes;
 use rustc_codegen_ssa::traits::*;
 use rustc_codegen_ssa::MemFlags;
 use rustc_hir::def_id::DefId;
+use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
 use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, LayoutError, LayoutOfHelpers, TyAndLayout,
 };
@@ -269,6 +270,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn invoke(
         &mut self,
         ty: &'ll Type,
+        fn_attrs: Option<&CodegenFnAttrs>,
         fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
         llfn: &'ll Value,
         args: &[&'ll Value],
@@ -277,7 +279,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         funclet: Option<&()>,
     ) -> &'ll Value {
         trace!("invoke");
-        let call = self.call(ty, None, llfn, args, funclet);
+        let call = self.call(ty, None, None, llfn, args, funclet);
         // exceptions arent a thing, go directly to the `then` block
         unsafe { llvm::LLVMBuildBr(self.llbuilder, then) };
         call
@@ -436,7 +438,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         let intrinsic = self.get_intrinsic(name);
         // call actually ignores the ty param for now, we just need it for conformance with nightly api
         // so give it a dummy type
-        let res = self.call(self.type_i1(), None, intrinsic, &[lhs, rhs], None);
+        let res = self.call(self.type_i1(), None,None, intrinsic, &[lhs, rhs], None);
         (self.extract_value(res, 0), self.extract_value(res, 1))
     }
 
@@ -518,7 +520,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         // self.call(vprintf, &[formatlist, valist], None);
 
         let trap = self.get_intrinsic("llvm.trap");
-        self.call(ty, None, trap, &[], None);
+        self.call(ty, None,None, trap, &[], None);
         unsafe { llvm::LLVMBuildLoad(self.llbuilder, ptr, unnamed()) }
     }
 
@@ -996,15 +998,15 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
     fn set_personality_fn(&mut self, _personality: &'ll Value) {}
 
-    fn cleanup_landing_pad(&mut self, _: &'ll Type, _: &'ll Value) -> &'ll Value {
+    fn cleanup_landing_pad(&mut self, _: &'ll Value) -> &'ll Value {
         todo!()
     }
 
     fn filter_landing_pad(&mut self, pers_fn: Self::Value) -> (Self::Value, Self::Value) {
         todo!()
     }
 
-    fn resume(&mut self, _exn: &'ll Value) {
+    fn resume(&mut self, _exn: &'ll Value, _exn1: &'ll Value) {
         self.unsupported("resumes");
     }
 
@@ -1090,6 +1092,7 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn call(
         &mut self,
         _: &'ll Type,
+        fn_attrs: Option<&CodegenFnAttrs>,
         _fn_abi: Option<&FnAbi<'tcx, Ty<'tcx>>>,
         llfn: &'ll Value,
         args: &[&'ll Value],
@@ -1263,6 +1266,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
         self.call(
             self.type_i1(),
             None,
+            None,
             lifetime_intrinsic,
             &[self.cx.const_u64(size), ptr],
             None,

crates/rustc_codegen_nvvm/src/const_ty.rs

@@ -4,10 +4,10 @@ use abi::Primitive::Pointer;
 use libc::c_uint;
 use rustc_ast::Mutability;
 use rustc_codegen_ssa::{
-    mir::place::PlaceRef,
     traits::{BaseTypeMethods,
              ConstMethods, DerivedTypeMethods, MiscMethods, StaticMethods},
 };
+use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{layout::TyAndLayout, ScalarInt};

crates/rustc_codegen_nvvm/src/context.rs

@@ -14,7 +14,8 @@ use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOf, FnAbiRequest, HasParamEnv, HasTyCtxt, LayoutError, TyAndLayout,
 };
 use rustc_middle::ty::layout::{FnAbiOfHelpers, LayoutOfHelpers};
-use rustc_middle::ty::{Ty, TypeFoldable, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::{Ty, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::TypeFoldable;
 use rustc_middle::{bug, span_bug, ty};
 use rustc_middle::{
     mir::mono::CodegenUnit,

crates/rustc_codegen_nvvm/src/debug_info/create_scope_map.rs

@@ -1,5 +1,6 @@
 use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext};
 use rustc_codegen_ssa::traits::*;
+use rustc_index::Idx;
 use rustc_middle::ty::layout::FnAbiOf;
 
 use crate::context::CodegenCx;

crates/rustc_codegen_nvvm/src/debug_info/metadata.rs

@@ -6,8 +6,8 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hir::def::CtorKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_index::Idx;
 use rustc_index::vec::{Idx, IndexVec};
-use rustc_abi::FieldIdx;
 use rustc_middle::mir::{self, GeneratorLayout};
 use rustc_middle::ty::layout::{self, IntegerExt, LayoutOf, PrimitiveExt, TyAndLayout};
 use rustc_middle::ty::subst::GenericArgKind;
@@ -1677,7 +1677,7 @@ impl<'tcx> VariantInfo<'_, 'tcx> {
     fn field_name(&self, i: usize, cx: &CodegenCx<'_, 'tcx>) -> String {
         let field_name = match *self {
             VariantInfo::Adt(variant) if variant.ctor_kind() != Some(CtorKind::Fn) => {
-                Some(variant.fields[FieldIdx::from_usize(i)].ident(cx.tcx).name)
+                Some(variant.fields[Idx::new(i)].ident(cx.tcx).name)
             }
             VariantInfo::Generator {
                 generator_layout,

crates/rustc_codegen_nvvm/src/intrinsic.rs

@@ -4,8 +4,8 @@ use crate::llvm::{self, Value};
 use crate::target;
 use crate::ty::LayoutLlvmExt;
 use crate::{builder::Builder, context::CodegenCx};
-use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::errors::InvalidMonomorphization::BasicIntegerType;
+use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::DerivedTypeMethods;
 use rustc_codegen_ssa::traits::{BaseTypeMethods, BuilderMethods, ConstMethods, OverflowOp};
 use rustc_codegen_ssa::{mir::operand::OperandRef, traits::IntrinsicCallMethods};
@@ -199,6 +199,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
             _ if simple.is_some() => self.call(
                 self.type_i1(),
                 None,
+                None,
                 simple.unwrap(),
                 &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
                 None,
@@ -208,6 +209,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 self.call(
                     self.type_i1(),
                     None,
+                    None,
                     expect,
                     &[args[0].immediate(), self.const_bool(true)],
                     None,
@@ -218,6 +220,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 self.call(
                     self.type_i1(),
                     None,
+                    None,
                     expect,
                     &[args[0].immediate(), self.const_bool(false)],
                     None,
@@ -227,7 +230,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 let try_func = args[0].immediate();
                 let data = args[1].immediate();
 
-                self.call(self.type_i1(), None, try_func, &[data], None);
+                self.call(self.type_i1(), None, None, try_func, &[data], None);
                 let ret_align = self.data_layout().i32_align.abi;
                 self.store(self.const_i32(0), llresult, ret_align)
             }
@@ -240,6 +243,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 self.call(
                     self.type_i1(),
                     None,
+                    None,
                     intrinsic,
                     &[args[0].immediate(), args[1].immediate()],
                     None,
@@ -318,7 +322,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                     _ => bug!(),
                 };
                 self.call(
-                    self.type_i1(),
+                    self.type_i1(),None,
                     None,
                     expect,
                     &[
@@ -345,9 +349,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                 let (width, signed) = if let Some(res) = int_type_width_signed(ty, self.cx) {
                     res
                 } else {
-                    tcx
-                        .sess
-                        .emit_err(BasicIntegerType { span, name, ty });
+                    tcx.sess.emit_err(BasicIntegerType { span, name, ty });
                     return;
                 };
                 if name == sym::saturating_add || name == sym::saturating_sub {
@@ -371,7 +373,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                             let y = self.const_bool(true);
                             let llvm_name = &format!("llvm.{}.i{}", &name_str[..4], width);
                             let llfn = self.get_intrinsic(llvm_name);
-                            self.call(self.type_i1(), None, llfn, &[args[0].immediate(), y], None)
+                            self.call(self.type_i1(), None,None, llfn, &[args[0].immediate(), y], None)
                         }
                         sym::ctpop => self.call(
                             self.type_i1(),
@@ -394,7 +396,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                             }
                         }
                         sym::bitreverse => self.call(
-                            self.type_i1(),
+                            self.type_i1(),None,
                             None,
                             self.get_intrinsic(&format!("llvm.bitreverse.i{}", width)),
                             &[args[0].immediate()],
@@ -421,7 +423,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
                                 width
                             );
                             let llfn = self.get_intrinsic(llvm_name);
-                            self.call(self.type_i1(), None, llfn, &[lhs, rhs], None)
+                            self.call(self.type_i1(), None, None, llfn, &[lhs, rhs], None)
                         }
                         _ => unreachable!(),
                     }
@@ -492,7 +494,7 @@ impl<'a, 'll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'a, 'll, 'tcx> {
     fn assume(&mut self, val: Self::Value) {
         trace!("Generate assume call with `{:?}`", val);
         let assume_intrinsic = self.get_intrinsic("llvm.assume");
-        self.call(self.type_i1(), None, assume_intrinsic, &[val], None);
+        self.call(self.type_i1(), None, None, assume_intrinsic, &[val], None);
     }
 
     fn expect(&mut self, cond: Self::Value, expected: bool) -> Self::Value {

crates/rustc_codegen_nvvm/src/lib.rs

@@ -61,6 +61,7 @@ use rustc_codegen_ssa::{
     traits::{CodegenBackend, ExtraBackendMethods, WriteBackendMethods},
     CodegenResults, CompiledModule, ModuleCodegen,
 };
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::{ErrorGuaranteed, FatalError, Handler};
 use rustc_hash::FxHashMap;
 use rustc_metadata::EncodedMetadata;
@@ -136,7 +137,7 @@ impl CodegenBackend for NvvmCodegenBackend {
         ongoing_codegen: Box<dyn std::any::Any>,
         sess: &Session,
         outputs: &OutputFilenames,
-    ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorGuaranteed> {
+    ) -> Result<(CodegenResults, FxIndexMap<WorkProductId, WorkProduct>), ErrorGuaranteed> {
         debug!("Join codegen");
         let (codegen_results, work_products) = ongoing_codegen
             .downcast::<OngoingCodegen<Self>>()
@@ -162,6 +163,10 @@ impl CodegenBackend for NvvmCodegenBackend {
         );
         Ok(())
     }
+
+    fn locale_resource(&self) -> &'static str {
+        todo!()
+    }
 }
 
 impl WriteBackendMethods for NvvmCodegenBackend {
@@ -256,7 +261,9 @@ impl WriteBackendMethods for NvvmCodegenBackend {
         }
     }
 
-    type TargetMachineError;  // idk wtf im supposed to do with this but ill fix later
+    type TargetMachineError;
+
+   // type TargetMachineError;  // idk wtf im supposed to do with this but ill fix later
 
     // fn run_lto_pass_manager(
     //     _: &CodegenContext<Self>,

crates/rustc_codegen_nvvm/src/link.rs

@@ -108,32 +108,32 @@ pub fn link<'tcx>(
         }
 
         if outputs.outputs.should_codegen() {
-            let out_filename: OutFileName = out_filename(
+            let out_filename = out_filename(
                 sess,
                 crate_type,
                 outputs,
                 codegen_results.crate_info.local_crate_name,
             );
             match crate_type {
                 CrateType::Rlib => {
-                    link_rlib(sess, codegen_results, &out_filename);
+                    link_rlib(sess, codegen_results, &out_filename.as_path());
                 }
                 CrateType::Executable | CrateType::Cdylib | CrateType::Dylib => {
                     let _ = link_exe(
                         &codegen_results.allocator_module,
                         sess,
                         crate_type,
-                        &out_filename,
+                        &out_filename.as_path(),
                         codegen_results,
                     );
                 }
-                other => sess.fatal(&format!("Invalid crate type: {:?}", other)),
+                other => sess.fatal(format!("Invalid crate type: {:?}", other)),
             }
         }
     }
 }
 
-fn link_rlib(sess: &Session, codegen_results: &CodegenResults, out_filename: &OutFileName) {
+fn link_rlib(sess: &Session, codegen_results: &CodegenResults, out_filename: &Path) {
     debug!("Linking rlib `{:?}`", out_filename);
     let mut file_list = Vec::<&Path>::new();
 
@@ -167,7 +167,7 @@ fn link_rlib(sess: &Session, codegen_results: &CodegenResults, out_filename: &Ou
         // the binary directly to ptx. We might want to add some way of linking in
         // ptx files or custom bitcode modules as "libraries" perhaps in the future.
         if let Some(name) = lib.name {
-            sess.err(&format!(
+            sess.err(format!(
                 "Adding native libraries to rlib is not supported in CUDA: {}",
                 name
             ));
@@ -224,7 +224,7 @@ fn codegen_into_ptx_file(
     sess: &Session,
     objects: &[PathBuf],
     rlibs: &[PathBuf],
-    out_filename: &OutFileName,
+    out_filename: &Path,
 ) -> io::Result<()> {
     debug!("Codegenning crate into PTX, allocator: {}, objects:\n{:#?}, rlibs:\n{:#?}, out_filename:\n{:#?}",
         allocator.is_some(),
@@ -285,21 +285,21 @@ fn codegen_into_ptx_file(
         Ok(bytes) => bytes,
         Err(err) => {
             // TODO(RDambrosio016): maybe include the nvvm log with this fatal error
-            sess.fatal(&err.to_string())
+            sess.fatal(err.to_string())
         }
     };
 
     std::fs::write(out_filename, ptx_bytes)
 }
 
-fn create_archive(sess: &Session, files: &[&Path], metadata: &[u8], out_filename: &OutFileName) {
+fn create_archive(sess: &Session, files: &[&Path], metadata: &[u8], out_filename: &Path) {
     if let Err(err) = try_create_archive(files, metadata, out_filename) {
-        sess.fatal(&format!("Failed to create archive: {}", err));
+        sess.fatal(format!("Failed to create archive: {}", err));
     }
 }
 
 fn try_create_archive(files: &[&Path],
-                      metadata: &[u8], out_filename: &OutFileName) -> io::Result<()> {
+                      metadata: &[u8], out_filename: &Path) -> io::Result<()> {
     let file = File::create(out_filename)?;
     let mut builder = Builder::new(file);
     {

crates/rustc_codegen_nvvm/src/mono_item.rs

@@ -11,7 +11,8 @@ pub use rustc_middle::mir::mono::MonoItem;
 use rustc_middle::mir::mono::{Linkage, Visibility};
 use rustc_middle::ty::layout::FnAbiOf;
 use rustc_middle::ty::layout::LayoutOf;
-use rustc_middle::ty::{self, Instance, TypeFoldable, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::{self, Instance, TypeVisitable, TypeVisitableExt};
+use rustc_middle::ty::TypeFoldable;
 use tracing::trace;
 
 pub(crate) fn visibility_to_llvm(linkage: Visibility) -> llvm::Visibility {