some bugfixes

Author: ZuseZ4

compiler/rustc_codegen_ssa/src/back/lto.rs

@@ -5,7 +5,6 @@ use rustc_data_structures::{fx::FxHashMap, memmap::Mmap};
 use std::ffi::CString;
 use std::sync::Arc;
 
-use rustc_data_structures::memmap::Mmap;
 use rustc_errors::FatalError;
 
 use super::write::CodegenContext;

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -424,7 +424,7 @@ fn generate_lto_work<B: ExtraBackendMethods>(
     } else {
         if !autodiff.is_empty() {
             let dcx = cgcx.create_dcx();
-            dcx.emit_fatal(AutodiffWithoutLto{});
+            dcx.handle().emit_fatal(AutodiffWithoutLto{});
         }
         assert!(needs_fat_lto.is_empty());
         let (lto_modules, copy_jobs) = B::run_thin_lto(cgcx, needs_thin_lto, import_only_modules)

compiler/rustc_codegen_ssa/src/base.rs

@@ -1,6 +1,3 @@
-use rustc_middle::ty::typetree_from;
-use rustc_ast::expand::typetree::{TypeTree, FncTree};
-
 use std::cmp;
 use std::collections::BTreeSet;
 use std::time::{Duration, Instant};

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -781,9 +781,9 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> AutoDiffAttrs {
         0 => return AutoDiffAttrs::inactive(),
         1 => attrs.get(0).unwrap(),
         _ => {
-            tcx.sess
+            tcx.dcx()
                 .struct_span_err(attrs[1].span, msg_once)
-                .span_label(attrs[1].span, "more than one")
+                .with_note("more than one")
                 .emit();
             return AutoDiffAttrs::inactive();
         }
@@ -797,19 +797,19 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> AutoDiffAttrs {
     }
 
     let [mode, input_activities @ .., ret_activity] = &list[..] else {
-        tcx.sess
+        tcx.dcx()
             .struct_span_err(attr.span, msg_once)
-            .span_label(attr.span, "Implementation bug in autodiff_attrs. Please report this!")
+            .with_note("Implementation bug in autodiff_attrs. Please report this!")
             .emit();
         return AutoDiffAttrs::inactive();
     };
     let mode = if let NestedMetaItem::MetaItem(MetaItem { path: ref p1, .. }) = mode {
         p1.segments.first().unwrap().ident
     } else {
         let msg = "autodiff attribute must contain autodiff mode";
-        tcx.sess
+        tcx.dcx()
             .struct_span_err(attr.span, msg)
-            .span_label(attr.span, "empty argument list")
+            .with_note("empty argument list")
             .emit();
         return AutoDiffAttrs::inactive();
     };
@@ -822,9 +822,9 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> AutoDiffAttrs {
         "ForwardFirst" => DiffMode::ForwardFirst,
         "ReverseFirst" => DiffMode::ReverseFirst,
         _ => {
-            tcx.sess
+            tcx.dcx()
                 .struct_span_err(attr.span, msg_mode)
-                .span_label(attr.span, "invalid mode")
+                .with_note("invalid mode")
                 .emit();
             return AutoDiffAttrs::inactive();
         }
@@ -835,9 +835,9 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> AutoDiffAttrs {
         p1.segments.first().unwrap().ident
     } else {
         let msg = "autodiff attribute must contain the return activity";
-        tcx.sess
+        tcx.dcx()
             .struct_span_err(attr.span, msg)
-            .span_label(attr.span, "missing return activity")
+            .with_note("missing return activity")
             .emit();
         return AutoDiffAttrs::inactive();
     };
@@ -847,9 +847,9 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> AutoDiffAttrs {
     let ret_activity = match DiffActivity::from_str(ret_symbol.as_str()) {
         Ok(x) => x,
         Err(_) => {
-            tcx.sess
+            tcx.dcx()
                 .struct_span_err(attr.span, msg_unknown_ret_activity)
-                .span_label(attr.span, "invalid return activity")
+                .with_note("invalid return activity")
                 .emit();
             return AutoDiffAttrs::inactive();
         }
@@ -862,19 +862,19 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> AutoDiffAttrs {
         let arg_symbol = if let NestedMetaItem::MetaItem(MetaItem { path: ref p2, .. }) = arg {
             p2.segments.first().unwrap().ident
         } else {
-            tcx.sess
+            tcx.dcx()
                 .struct_span_err(attr.span, msg_arg_activity)
-                .span_label(attr.span, "Implementation bug, please report this!")
+                .with_note("Implementation bug, please report this!")
                 .emit();
             return AutoDiffAttrs::inactive();
         };
 
         match DiffActivity::from_str(arg_symbol.as_str()) {
             Ok(arg_activity) => arg_activities.push(arg_activity),
             Err(_) => {
-                tcx.sess
+                tcx.dcx()
                     .struct_span_err(attr.span, msg_unknown_ret_activity)
-                    .span_label(attr.span, "invalid input activity")
+                    .with_note("invalid input activity")
                     .emit();
                 return AutoDiffAttrs::inactive();
             }
@@ -889,9 +889,9 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> AutoDiffAttrs {
         msg = format!("Invalid return activity {} for {} mode", ret_activity, mode);
     }
     if msg != "".to_string() {
-        tcx.sess
+        tcx.dcx()
             .struct_span_err(attr.span, msg)
-            .span_label(attr.span, "invalid activity")
+            .with_note("invalid activity")
             .emit();
         return AutoDiffAttrs::inactive();
     }

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1539,6 +1539,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     align,
                     bx.const_usize(copy_bytes),
                     MemFlags::empty(),
+                    None,
                 );
                 // ...and then load it with the ABI type.
                 let cast_ty = bx.cast_backend_type(cast);

compiler/rustc_codegen_ssa/src/mir/intrinsic.rs

@@ -1,6 +1,7 @@
+use tracing::trace;
 use rustc_middle::ty::typetree_from;
 use rustc_ast::expand::typetree::{TypeTree, FncTree};
-use crate::rustc_middle::ty::layout::HasTyCtxt;
+use rustc_middle::ty::layout::HasTyCtxt;
 
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_middle::{bug, span_bug};
@@ -42,6 +43,7 @@ fn copy_intrinsic<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         bx.memmove(dst, align, src, align, size, flags, Some(fnc_tree));
     } else {
         bx.memcpy(dst, align, src, align, size, flags, Some(fnc_tree));
+    }
 }
 
 fn memset_intrinsic<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -339,7 +339,7 @@ pub trait BuilderMethods<'a, 'tcx>:
             temp.val.store_with_flags(self, dst.with_type(layout), flags);
         } else if !layout.is_zst() {
             let bytes = self.const_usize(layout.size.bytes());
-            self.memcpy(dst.llval, dst.align, src.llval, src.align, bytes, flags);
+            self.memcpy(dst.llval, dst.align, src.llval, src.align, bytes, flags, None);
         }
     }
 

compiler/rustc_monomorphize/src/partitioning.rs

@@ -92,6 +92,7 @@
 //! source-level module, functions from the same module will be available for
 //! inlining, even when they are not marked `#[inline]`.
 
+use tracing::trace;
 use std::cmp;
 use std::collections::hash_map::Entry;
 use std::fs::{self, File};
@@ -100,7 +101,7 @@ use std::path::{Path, PathBuf};
 
 use rustc_ast::expand::autodiff_attrs::{AutoDiffItem, AutoDiffAttrs};
 use rustc_middle::ty::{
-    self, visit::TypeVisitableExt, InstanceDef, ParamEnv, TyCtxt,
+    self, visit::TypeVisitableExt, ParamEnv, TyCtxt,
     fnc_typetrees
 };
 use rustc_symbol_mangling::symbol_name_for_instance_in_crate;
@@ -121,8 +122,7 @@ use rustc_middle::mir::mono::{
     Visibility,
 };
 use rustc_middle::ty::print::{characteristic_def_id_of_type, with_no_trimmed_paths};
-use rustc_middle::ty::visit::TypeVisitableExt;
-use rustc_middle::ty::{self, InstanceKind, TyCtxt};
+use rustc_middle::ty::InstanceKind;
 use rustc_middle::util::Providers;
 use rustc_session::config::{DumpMonoStatsFormat, SwitchWithOptPath};
 use rustc_session::CodegenUnits;

compiler/rustc_resolve/src/lib.rs

@@ -1136,7 +1136,7 @@ pub struct Resolver<'a, 'tcx> {
     node_id_to_def_id: NodeMap<Feed<'tcx, LocalDefId>>,
     def_id_to_node_id: IndexVec<LocalDefId, ast::NodeId>,
 
-    autodiff_map: Default::default(),
+    autodiff_map: FxHashMap<LocalDefId, LocalDefId>,
 
     /// Indices of unnamed struct or variant fields with unresolved attributes.
     placeholder_field_indices: FxHashMap<NodeId, usize>,