Rollup of 23 pull requests

compiler/rustc_ast/src/attr/mod.rs

@@ -246,29 +246,6 @@ impl AttributeExt for Attribute {
         }
     }
 
-    fn is_doc_keyword_or_attribute(&self) -> bool {
-        match &self.kind {
-            AttrKind::Normal(_) => {
-                if self.has_name(sym::doc)
-                    && let Some(items) = self.meta_item_list()
-                {
-                    for item in items {
-                        if item.has_name(sym::keyword) || item.has_name(sym::attribute) {
-                            return true;
-                        }
-                    }
-                }
-            }
-            _ => {}
-        }
-
-        false
-    }
-
-    fn is_rustc_doc_primitive(&self) -> bool {
-        self.has_name(sym::rustc_doc_primitive)
-    }
-
     /// Returns whether this attribute is any of the proc macro attributes.
     /// i.e. `proc_macro`, `proc_macro_attribute` or `proc_macro_derive`.
     fn is_proc_macro_attr(&self) -> bool {
@@ -993,12 +970,6 @@ pub trait AttributeExt: Debug + 'static {
     /// commented module (for inner doc) vs within its parent module (for outer
     /// doc).
     fn doc_resolution_scope(&self) -> Option<AttrStyle>;
-
-    /// Returns `true` is this attribute contains `doc(keyword)` or `doc(attribute)`.
-    fn is_doc_keyword_or_attribute(&self) -> bool;
-
-    /// Returns `true` if this is a `#[rustc_doc_primitive]` attribute.
-    fn is_rustc_doc_primitive(&self) -> bool;
 }
 
 // FIXME(fn_delegation): use function delegation instead of manually forwarding

compiler/rustc_attr_ir/src/attr.rs

@@ -267,12 +267,4 @@ impl AttributeExt for Attribute {
             )
         )
     }
-
-    fn is_doc_keyword_or_attribute(&self) -> bool {
-        matches!(self, Attribute::Parsed(AttributeKind::Doc(d)) if d.attribute.is_some() || d.keyword.is_some())
-    }
-
-    fn is_rustc_doc_primitive(&self) -> bool {
-        matches!(self, Attribute::Parsed(AttributeKind::RustcDocPrimitive(..)))
-    }
 }

compiler/rustc_borrowck/src/diagnostics/region_errors.rs

@@ -1109,6 +1109,12 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
 
             let mut v = ty::TraitObjectVisitor(vec![]);
             v.visit_ty_unambig(f.ty);
+
+            if v.0.is_empty() {
+                // No trait object found in this return
+                continue;
+            }
+
             let mut span: MultiSpan = v.0.iter().map(|x| x.span).collect::<Vec<_>>().into();
             // Display the item and variant lines.
             for def_span in def_spans {

compiler/rustc_codegen_gcc/src/builder.rs

@@ -17,8 +17,8 @@ use rustc_codegen_ssa::common::{
 use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{
-    BackendTypes, BaseTypeCodegenMethods, BuilderMethods, ConstCodegenMethods,
-    LayoutTypeCodegenMethods, OverflowOp, ReturnSlot, StaticBuilderMethods,
+    BackendTypes, BaseTypeCodegenMethods, BuilderMethods, ConstCodegenMethods, OverflowOp,
+    ReturnSlot, StaticBuilderMethods,
 };
 use rustc_data_structures::fx::FxHashSet;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
@@ -1187,11 +1187,9 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         let align = dest.val.align.restrict_for_offset(dest.layout.field(self.cx(), 0).size);
         cg_elem.val.store(self, PlaceRef::new_sized_aligned(current_val, cg_elem.layout, align));
 
-        let next = self.inbounds_gep(
-            self.backend_type(cg_elem.layout),
-            current.to_rvalue(),
-            &[self.const_usize(1)],
-        );
+        let next = self
+            .inbounds_ptradd(current.to_rvalue(), self.const_usize(cg_elem.layout.size.bytes()));
+        let next = self.context.new_cast(self.location, next, ptr_type);
         self.llbb().add_assignment(self.location, current, next);
         self.br(header_bb);
 
@@ -1270,52 +1268,29 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         );
     }
 
-    fn gep(
-        &mut self,
-        typ: Type<'gcc>,
-        ptr: RValue<'gcc>,
-        indices: &[RValue<'gcc>],
-    ) -> RValue<'gcc> {
-        // NOTE: due to opaque pointers now being used, we need to cast here.
-        let ptr = self.context.new_cast(self.location, ptr, typ.make_pointer());
+    fn gep(&mut self, stride: Size, ptr: RValue<'gcc>, index: RValue<'gcc>) -> RValue<'gcc> {
         let ptr_type = ptr.get_type();
-        let mut pointee_type = ptr.get_type();
         // NOTE: we cannot use array indexing here like in inbounds_gep because array indexing is
         // always considered in bounds in GCC (FIXME(antoyo): to be verified).
         // So, we have to cast to a number.
-        let mut result = self.context.new_bitcast(self.location, ptr, self.sizet_type);
-        // FIXME(antoyo): if there were more than 1 index, this code is probably wrong and would
-        // require dereferencing the pointer.
-        for index in indices {
-            pointee_type = pointee_type.get_pointee().expect("pointee type");
-            #[cfg(feature = "master")]
-            let pointee_size = {
-                let size = self.cx.context.new_sizeof(pointee_type);
-                self.context.new_cast(self.location, size, index.get_type())
-            };
-            #[cfg(not(feature = "master"))]
-            let pointee_size =
-                self.context.new_rvalue_from_int(index.get_type(), pointee_type.get_size() as i32);
-            result = result + self.gcc_int_cast(*index * pointee_size, self.sizet_type);
-        }
+        let ptr = self.context.new_bitcast(self.location, ptr, self.sizet_type);
+        let pointee_size =
+            self.context.new_rvalue_from_int(index.get_type(), stride.bytes() as i32);
+        let result = ptr + self.gcc_int_cast(index * pointee_size, self.sizet_type);
         self.context.new_bitcast(self.location, result, ptr_type)
     }
 
     fn inbounds_gep(
         &mut self,
-        typ: Type<'gcc>,
+        stride: Size,
         ptr: RValue<'gcc>,
-        indices: &[RValue<'gcc>],
+        index: RValue<'gcc>,
     ) -> RValue<'gcc> {
+        let typ = self.cx.type_array(self.cx.type_i8(), stride.bytes());
         // NOTE: due to opaque pointers now being used, we need to cast here.
         let ptr = self.context.new_cast(self.location, ptr, typ.make_pointer());
         // NOTE: array indexing is always considered in bounds in GCC (FIXME(antoyo): to be verified).
-        let mut indices = indices.iter();
-        let index = indices.next().expect("first index in inbounds_gep");
-        let mut result = self.context.new_array_access(self.location, ptr, *index);
-        for index in indices {
-            result = self.context.new_array_access(self.location, result, *index);
-        }
+        let result = self.context.new_array_access(self.location, ptr, index);
         result.get_address(self.location)
     }
 

compiler/rustc_codegen_gcc/src/intrinsic/simd.rs

@@ -11,7 +11,7 @@ use rustc_codegen_ssa::diagnostics::ExpectedPointerMutability;
 use rustc_codegen_ssa::diagnostics::InvalidMonomorphization;
 use rustc_codegen_ssa::mir::operand::OperandRef;
 use rustc_codegen_ssa::mir::place::PlaceRef;
-use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods, LayoutTypeCodegenMethods};
+use rustc_codegen_ssa::traits::{BaseTypeCodegenMethods, BuilderMethods};
 #[cfg(feature = "master")]
 use rustc_hir as hir;
 use rustc_middle::mir::BinOp;
@@ -671,7 +671,6 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
             );
         }
 
-        let pointee_type = bx.backend_type(layout);
         let pointers = args[0].immediate();
         let offsets = args[1].immediate();
         let elem_type = llret_ty.dyncast_vector().expect("vector return type").get_element_type();
@@ -680,7 +679,7 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
                 let index = bx.context.new_rvalue_from_long(bx.usize_type, i as _);
                 let pointer = bx.extract_element(pointers, index);
                 let offset = bx.extract_element(offsets, index);
-                let pointer = bx.gep(pointee_type, pointer, &[offset]);
+                let pointer = bx.gep(layout.size, pointer, offset);
                 // GCC has no pointer vectors, so the lanes are `usize`.
                 bx.ptrtoint(pointer, elem_type)
             })

compiler/rustc_codegen_llvm/src/abi.rs

@@ -217,7 +217,7 @@ impl LlvmType for CastTarget {
         let prefix_args = self.prefix.iter().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)
+        cx.type_struct(&args)
     }
 }
 

compiler/rustc_codegen_llvm/src/asm.rs

@@ -335,7 +335,7 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
         let output_type = match &output_types[..] {
             [] => self.type_void(),
             [ty] => ty,
-            tys => self.type_struct(tys, false),
+            tys => self.type_struct(tys),
         };
         let dialect = match asm_arch {
             InlineAsmArch::X86 | InlineAsmArch::X86_64

compiler/rustc_codegen_llvm/src/back/llvm_backend.rs

@@ -443,7 +443,7 @@ impl CodegenBackend for LlvmCodegenBackend {
 
 pub struct ModuleLlvm {
     llcx_raw: ptr::NonNull<llvm::ContextRaw>,
-    llmod_raw: *const llvm::Module,
+    llmod_raw: ptr::NonNull<llvm::ModuleRaw>,
 
     // This field is `ManuallyDrop` because it is important that the `TargetMachine`
     // is disposed prior to the `Context` being disposed otherwise UAFs can occur.
@@ -461,22 +461,15 @@ pub struct ModuleLlvm {
 // `ModuleLlvm` owns the context and only allows borrowing LLVM objects tied to the context.
 unsafe impl Send for ModuleLlvm {}
 
-/// Converts an unbranded pointer-to-context to a lifetime-branded [`llvm::Context`].
-///
-/// # Safety
-/// - The pointer must be a valid LLVM context.
-/// - If the context is passed to safe code, its caller-requested lifetime must be distinct
-///   from that of any other context, and must not outlive the underlying context.
-unsafe fn wrap_llcx<'ll>(llcx_raw: ptr::NonNull<llvm::ContextRaw>) -> llvm::Context<'ll> {
-    llvm::Context { llcx_raw, _invariant_ll: PhantomData }
-}
-
 /// Shared helper to call [`llvm::LLVMContextCreate`] and then configure
 /// [`llvm::LLVMContextSetDiscardValueNames`].
 fn create_context_and_set_fewer_names(fewer_names: bool) -> ptr::NonNull<llvm::ContextRaw> {
     unsafe {
         let llcx_raw = llvm::LLVMContextCreate();
-        llvm::LLVMContextSetDiscardValueNames(wrap_llcx(llcx_raw), fewer_names.to_llvm_bool());
+        llvm::LLVMContextSetDiscardValueNames(
+            llvm::wrap_llcx(llcx_raw),
+            fewer_names.to_llvm_bool(),
+        );
         llcx_raw
     }
 }
@@ -485,7 +478,8 @@ impl ModuleLlvm {
     pub(crate) fn new(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
             let llcx_raw = create_context_and_set_fewer_names(tcx.sess.fewer_names());
-            let llmod_raw = context::create_module(tcx, wrap_llcx(llcx_raw), mod_name);
+            let llmod_raw =
+                context::create_module(tcx, llvm::wrap_llcx(llcx_raw), mod_name).llmod_raw();
             ModuleLlvm {
                 llmod_raw,
                 llcx_raw,
@@ -498,7 +492,8 @@ impl ModuleLlvm {
     pub(crate) fn new_metadata(tcx: TyCtxt<'_>, mod_name: &str) -> Self {
         unsafe {
             let llcx_raw = create_context_and_set_fewer_names(tcx.sess.fewer_names());
-            let llmod_raw = context::create_module(tcx, wrap_llcx(llcx_raw), mod_name);
+            let llmod_raw =
+                context::create_module(tcx, llvm::wrap_llcx(llcx_raw), mod_name).llmod_raw();
             ModuleLlvm {
                 llmod_raw,
                 llcx_raw,
@@ -517,7 +512,8 @@ impl ModuleLlvm {
     ) -> Self {
         unsafe {
             let llcx_raw = create_context_and_set_fewer_names(cgcx.fewer_names);
-            let llmod_raw = back::lto::parse_module(wrap_llcx(llcx_raw), name, buffer, dcx);
+            let llmod_raw =
+                back::lto::parse_module(llvm::wrap_llcx(llcx_raw), name, buffer, dcx).llmod_raw();
             let tm = tm_factory(dcx, TargetMachineFactoryConfig::new(cgcx, name.to_str().unwrap()));
 
             ModuleLlvm {
@@ -538,12 +534,9 @@ impl ModuleLlvm {
         &self,
         inner_fn: impl for<'ll> FnOnce(ModuleRefs<'ll>) -> R,
     ) -> R {
-        inner_fn(ModuleRefs {
-            llcx: unsafe { wrap_llcx(self.llcx_raw) },
-            llmod: unsafe { &*self.llmod_raw },
-            tm: self.tm.raw(),
-            _ph: PhantomData,
-        })
+        let llcx = unsafe { llvm::wrap_llcx(self.llcx_raw) };
+        let llmod = unsafe { llvm::wrap_llmod(llcx, self.llmod_raw) };
+        inner_fn(ModuleRefs { llcx, llmod, tm: self.tm.raw(), _ph: PhantomData })
     }
 }
 
@@ -560,7 +553,7 @@ impl Drop for ModuleLlvm {
 #[derive(Clone, Copy)]
 pub(crate) struct ModuleRefs<'ll> {
     pub(crate) llcx: llvm::Context<'ll>,
-    pub(crate) llmod: &'ll llvm::Module,
+    pub(crate) llmod: llvm::Module<'ll>,
     pub(crate) tm: &'ll llvm::TargetMachine,
     /// Make sure `'ll` is invariant, even if no fields happen to require that.
     ///

compiler/rustc_codegen_llvm/src/back/lto.rs

@@ -695,7 +695,7 @@ pub struct ModuleBuffer {
 }
 
 impl ModuleBuffer {
-    pub(crate) fn new(m: &llvm::Module, is_thin: bool) -> ModuleBuffer {
+    pub(crate) fn new<'ll>(m: llvm::Module<'ll>, is_thin: bool) -> ModuleBuffer {
         unsafe {
             let buffer = llvm::LLVMRustModuleSerialize(m, is_thin);
             ModuleBuffer { data: Buffer(buffer) }
@@ -859,7 +859,7 @@ pub(crate) fn parse_module<'ll>(
     name: &CStr,
     data: &[u8],
     dcx: DiagCtxtHandle<'_>,
-) -> &'ll llvm::Module {
+) -> llvm::Module<'ll> {
     unsafe {
         llvm::LLVMRustParseBitcodeForLTO(llcx, data.as_ptr(), data.len(), name.as_ptr())
             .unwrap_or_else(|| write::llvm_err(dcx, LlvmError::ParseBitcode))

compiler/rustc_codegen_llvm/src/back/write.rs

@@ -54,7 +54,7 @@ fn write_output_file<'ll>(
     dcx: DiagCtxtHandle<'_>,
     target: &'ll llvm::TargetMachine,
     no_builtins: bool,
-    m: &'ll llvm::Module,
+    m: llvm::Module<'ll>,
     output: &Path,
     dwo_output: Option<&Path>,
     file_type: llvm::FileType,
@@ -1207,7 +1207,7 @@ pub(crate) fn bitcode_section_name(cgcx: &CodegenContext) -> &'static CStr {
 fn embed_bitcode<'ll>(
     cgcx: &CodegenContext,
     llcx: llvm::Context<'ll>,
-    llmod: &'ll llvm::Module,
+    llmod: llvm::Module<'ll>,
     bitcode: &[u8],
 ) {
     // We're adding custom sections to the output object file, but we definitely
@@ -1293,7 +1293,7 @@ fn embed_bitcode<'ll>(
 fn create_msvc_imps<'ll>(
     cgcx: &CodegenContext,
     llcx: llvm::Context<'ll>,
-    llmod: &'ll llvm::Module,
+    llmod: llvm::Module<'ll>,
 ) {
     if !cgcx.msvc_imps_needed {
         return;
@@ -1359,7 +1359,11 @@ fn record_artifact_size(
     }
 }
 
-fn record_llvm_cgu_instructions_stats(prof: &SelfProfilerRef, name: &str, llmod: &llvm::Module) {
+fn record_llvm_cgu_instructions_stats<'ll>(
+    prof: &SelfProfilerRef,
+    name: &str,
+    llmod: llvm::Module<'ll>,
+) {
     if !prof.enabled() {
         return;
     }

compiler/rustc_codegen_llvm/src/base.rs

@@ -50,11 +50,11 @@ impl<'ll> Iterator for ValueIter<'ll> {
     }
 }
 
-pub(crate) fn iter_globals(llmod: &llvm::Module) -> ValueIter<'_> {
+pub(crate) fn iter_globals<'ll>(llmod: llvm::Module<'ll>) -> ValueIter<'ll> {
     unsafe { ValueIter { cur: llvm::LLVMGetFirstGlobal(llmod), step: llvm::LLVMGetNextGlobal } }
 }
 
-pub(crate) fn iter_global_aliases(llmod: &llvm::Module) -> ValueIter<'_> {
+pub(crate) fn iter_global_aliases<'ll>(llmod: llvm::Module<'ll>) -> ValueIter<'ll> {
     unsafe {
         ValueIter { cur: llvm::LLVMGetFirstGlobalAlias(llmod), step: llvm::LLVMGetNextGlobalAlias }
     }