save

Author: ZelboK

crates/rustc_codegen_nvvm/src/back.rs

@@ -1,4 +1,4 @@
-use crate::llvm::{self};
+use crate::llvm::{self, TargetMachine};
 use crate::override_fns::define_or_override_fn;
 use crate::{builder::Builder, context::CodegenCx, lto::ThinBuffer, LlvmMod, NvvmCodegenBackend};
 use cstr::cstr;
@@ -105,7 +105,7 @@ pub fn target_machine_factory(
         .unwrap_or(sess.target.trap_unreachable);
 
     Arc::new(move |_config: TargetMachineFactoryConfig| {
-        let tm = unsafe {
+        let tm: Option<&mut TargetMachine> = unsafe {
             llvm::LLVMRustCreateTargetMachine(
                 triple.as_ptr(),
                 std::ptr::null(),
@@ -121,6 +121,7 @@ pub fn target_machine_factory(
                 false,
             )
         };
+       
         tm.ok_or_else(|| {
             format!(
                 "Could not create LLVM TargetMachine for triple: {}",

crates/rustc_codegen_nvvm/src/builder.rs

@@ -18,8 +18,9 @@ use rustc_middle::ty::layout::{
 };
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_span::Span;
+use rustc_target::abi::{Abi, Align, Scalar, Size, WrappingRange};
 use rustc_target::abi::call::FnAbi;
-use rustc_target::abi::{self, AddressSpace, Align, Size, WrappingRange};
+use rustc_target::abi::{self, AddressSpace};
 use rustc_target::spec::{HasTargetSpec, Target};
 use std::borrow::Cow;
 use std::ffi::{CStr, CString};
@@ -998,7 +999,7 @@ 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 Value) -> &'ll Value {
+    fn cleanup_landing_pad(&mut self, _: &'ll Value)-> (Self::Value, Self::Value) {
         todo!()
     }
 
@@ -1134,6 +1135,38 @@ impl<'ll, 'tcx, 'a> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn do_not_inline(&mut self, llret: &'ll Value) {
         llvm::Attribute::NoInline.apply_callsite(llvm::AttributePlace::Function, llret);
     }
+
+    fn to_immediate(&mut self, val: Self::Value, layout: TyAndLayout<'_>) -> Self::Value {
+        if let Abi::Scalar(scalar) = layout.abi {
+            self.to_immediate_scalar(val, scalar)
+        } else {
+            val
+        }
+    }
+
+    fn cast_float_to_int(
+        &mut self,
+        signed: bool,
+        x: Self::Value,
+        dest_ty: Self::Type,
+    ) -> Self::Value {
+        let in_ty = self.cx().val_ty(x);
+        let (float_ty, int_ty) = if self.cx().type_kind(dest_ty) == TypeKind::Vector
+            && self.cx().type_kind(in_ty) == TypeKind::Vector
+        {
+            (self.cx().element_type(in_ty), self.cx().element_type(dest_ty))
+        } else {
+            (in_ty, dest_ty)
+        };
+        assert!(matches!(self.cx().type_kind(float_ty), TypeKind::Float | TypeKind::Double));
+        assert_eq!(self.cx().type_kind(int_ty), TypeKind::Integer);
+
+        if let Some(false) = self.cx().sess().opts.unstable_opts.saturating_float_casts {
+            return if signed { self.fptosi(x, dest_ty) } else { self.fptoui(x, dest_ty) };
+        }
+
+        if signed { self.fptosi_sat(x, dest_ty) } else { self.fptoui_sat(x, dest_ty) }
+    }
 }
 
 impl<'a, 'll, 'tcx> StaticBuilderMethods for Builder<'a, 'll, 'tcx> {

crates/rustc_codegen_nvvm/src/debug_info/metadata.rs

@@ -20,7 +20,7 @@ use rustc_span::{FileNameDisplayPreference, DUMMY_SP};
 use rustc_target::abi::{Abi, Align, HasDataLayout, Integer, TagEncoding};
 use rustc_target::abi::{
     Primitive::{self, *},
-    Size, VariantIdx, Variants,
+    Size, VariantIdx, Variants, FieldIdx
 };
 
 use crate::context::CodegenCx;
@@ -982,7 +982,7 @@ pub fn compile_unit_metadata<'ll>(
     _codegen_unit_name: &str,
     debug_context: &CrateDebugContext<'ll, '_>,
 ) -> &'ll DIDescriptor {
-    let name_in_debuginfo = match tcx.sess.local_crate_source_file {
+    let name_in_debuginfo = match tcx.sess.local_crate_source_file() {
         Some(ref path) => path.clone(),
         None => PathBuf::from(&*tcx.crate_name(LOCAL_CRATE).as_str()),
     };
@@ -1676,7 +1676,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[usize::from_usize(i)].ident(cx.tcx).name)
+                Some(variant.fields[FieldIdx::from_usize(i)].ident(cx.tcx).name)
             }
             VariantInfo::Generator {
                 generator_layout,

crates/rustc_codegen_nvvm/src/lib.rs

@@ -175,6 +175,7 @@ impl WriteBackendMethods for NvvmCodegenBackend {
     type TargetMachine = &'static mut llvm::TargetMachine;
     type ThinData = ();
     type ThinBuffer = ThinBuffer;
+    type TargetMachineError = &'static mut llvm::MyTargetMachineError; // fix later 
 
     fn run_link(
         _cgcx: &CodegenContext<Self>,
@@ -261,7 +262,6 @@ impl WriteBackendMethods for NvvmCodegenBackend {
         }
     }
 
-    type TargetMachineError;
 
    // type TargetMachineError;  // idk wtf im supposed to do with this but ill fix later
 

crates/rustc_codegen_nvvm/src/link.rs

@@ -167,15 +167,10 @@ fn link_rlib(sess: &Session, codegen_results: &CodegenResults, out_filename: &Pa
         // but including libraries doesnt make sense because nvvm would have to translate
         // 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.
-        match lib.name {
-            Some(name) => {
-                sess.err(format!(
-                    "Adding native libraries to rlib is not supported in CUDA: {}",
-                    name
-                ));
-            }
-            _ => (),
-        }
+        sess.err(format!(
+            "Adding native libraries to rlib is not supported in CUDA: {}",
+            lib.name
+        ));
     }
     trace!("Files linked in rlib:\n{:#?}", file_list);
 

crates/rustc_codegen_nvvm/src/llvm.rs

@@ -491,10 +491,23 @@ extern "C" {
 extern "C" {
     pub type TargetMachine;
 }
+extern "C" {
+    pub type TargetMachineError;
+}
 extern "C" {
     pub(crate) type MemoryBuffer;
 }
 
+pub struct MyTargetMachineError {
+    inner: *mut TargetMachineError,
+}
+
+impl std::fmt::Debug for MyTargetMachineError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "MyTargetMachineError at {:p}", self.inner)
+    }
+}
+
 /// LLVMRustChecksumKind
 #[derive(Copy, Clone)]
 #[repr(C)]