codegen eii

Author: jdonszelmann

compiler/rustc_ast/src/ast.rs

@@ -1889,6 +1889,7 @@ pub struct MacroDef {
 pub struct EIIMacroFor {
     pub extern_item_path: Path,
     pub impl_unsafe: bool,
+    pub span: Span,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)]

compiler/rustc_ast/src/mut_visit.rs

@@ -747,7 +747,7 @@ fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {
 
 fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {
     let MacroDef { body, macro_rules: _, eii_macro_for } = macro_def;
-    if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = eii_macro_for {
+    if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _, span: _ }) = eii_macro_for {
         vis.visit_path(extern_item_path);
     }
     visit_delim_args(vis, body);

compiler/rustc_ast/src/visit.rs

@@ -440,7 +440,9 @@ impl WalkItemKind for ItemKind {
             ItemKind::MacCall(mac) => try_visit!(visitor.visit_mac_call(mac)),
             ItemKind::MacroDef(ts) => {
                 try_visit!(visitor.visit_mac_def(ts, id));
-                if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = &ts.eii_macro_for {
+                if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _, span: _ }) =
+                    &ts.eii_macro_for
+                {
                     try_visit!(visitor.visit_path(extern_item_path, id));
                 }
             }

compiler/rustc_ast_lowering/src/item.rs

@@ -2,7 +2,7 @@ use rustc_abi::ExternAbi;
 use rustc_ast::ptr::P;
 use rustc_ast::visit::AssocCtxt;
 use rustc_ast::*;
-use rustc_attr_parsing::AttributeKind;
+use rustc_attr_parsing::{AttributeKind, EIIDecl};
 use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
@@ -24,7 +24,6 @@ use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
     ResolverAstLoweringExt,
 };
-use crate::GenericArgsMode;
 
 pub(super) struct ItemLowerer<'a, 'hir> {
     pub(super) tcx: TyCtxt<'hir>,
@@ -191,13 +190,14 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ))]
             }
             ItemKind::MacroDef(MacroDef {
-                eii_macro_for: Some(EIIMacroFor { extern_item_path, impl_unsafe }),
+                eii_macro_for: Some(EIIMacroFor { extern_item_path, impl_unsafe, span }),
                 ..
             }) => {
-                vec![hir::Attribute::Parsed(AttributeKind::EiiMacroFor {
+                vec![hir::Attribute::Parsed(AttributeKind::EiiMacroFor(EIIDecl {
                     eii_extern_item: self.lower_path_simple_eii(id, extern_item_path),
                     impl_unsafe: *impl_unsafe,
-                })]
+                    span: self.lower_span(*span),
+                }))]
             }
             ItemKind::ExternCrate(..)
             | ItemKind::Use(..)

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -139,7 +139,7 @@ impl Deprecation {
     }
 }
 
-#[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+#[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
 pub struct EIIImpl {
     pub eii_macro: DefId,
     pub impl_marked_unsafe: bool,
@@ -148,6 +148,14 @@ pub struct EIIImpl {
     pub is_default: bool,
 }
 
+#[derive(Copy, Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub struct EIIDecl {
+    pub eii_extern_item: DefId,
+    /// whether or not it is unsafe to implement this EII
+    pub impl_unsafe: bool,
+    pub span: Span,
+}
+
 /// Represent parsed, *built in*, inert attributes.
 ///
 /// That means attributes that are not actually ever expanded.
@@ -200,11 +208,8 @@ pub enum AttributeKind {
         comment: Symbol,
     },
     EiiImpl(ThinVec<EIIImpl>),
-    EiiMacroFor {
-        eii_extern_item: DefId,
-        /// whether or not it is unsafe to implement this EII
-        impl_unsafe: bool,
-    },
+    EiiMacroFor(EIIDecl),
+    EiiMangleExtern,
     MacroTransparency(Transparency),
     Repr(ThinVec<(ReprAttr, Span)>),
     Stability {

compiler/rustc_attr_parsing/src/attributes/eii.rs

@@ -0,0 +1,17 @@
+use rustc_attr_data_structures::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use super::{AcceptContext, SingleAttributeParser};
+use crate::parser::ArgParser;
+
+pub(crate) struct EiiMangleExternParser;
+
+impl SingleAttributeParser for EiiMangleExternParser {
+    const PATH: &'static [Symbol] = &[sym::eii_mangle_extern];
+
+    fn on_duplicate(_cx: &AcceptContext<'_>, _first_span: Span) {}
+    fn convert(_cx: &AcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        assert!(args.no_args());
+        Some(AttributeKind::EiiMangleExtern)
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -14,6 +14,7 @@ use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
 use crate::attributes::confusables::ConfusablesParser;
 use crate::attributes::deprecation::DeprecationParser;
+use crate::attributes::eii::EiiMangleExternParser;
 use crate::attributes::repr::ReprParser;
 use crate::attributes::stability::{
     BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
@@ -76,6 +77,7 @@ attribute_groups!(
         // tidy-alphabetical-start
         Single<ConstStabilityIndirectParser>,
         Single<DeprecationParser>,
+        Single<EiiMangleExternParser>,
         Single<TransparencyParser>,
         // tidy-alphabetical-end
     ];

compiler/rustc_builtin_macros/src/eii.rs

@@ -77,7 +77,7 @@ fn eii_(
     let item = item.into_inner();
 
     let ast::Item {
-        attrs,
+        mut attrs,
         id: _,
         span: item_span,
         vis,
@@ -184,6 +184,21 @@ fn eii_(
     }
 
     // extern "…" { safe fn item(); }
+    // #[eii_mangle_extern]
+    attrs.push(ast::Attribute {
+        kind: ast::AttrKind::Normal(P(ast::NormalAttr {
+            item: ast::AttrItem {
+                unsafety: ast::Safety::Default,
+                path: ast::Path::from_ident(Ident::new(sym::eii_mangle_extern, span)),
+                args: ast::AttrArgs::Empty,
+                tokens: None,
+            },
+            tokens: None,
+        })),
+        id: ecx.sess.psess.attr_id_generator.mk_attr_id(),
+        style: ast::AttrStyle::Outer,
+        span,
+    });
     let extern_block = Annotatable::Item(P(ast::Item {
         attrs: ast::AttrVec::default(),
         id: ast::DUMMY_NODE_ID,
@@ -264,6 +279,7 @@ fn eii_(
             eii_macro_for: Some(ast::EIIMacroFor {
                 extern_item_path: ast::Path::from_ident(item_name),
                 impl_unsafe,
+                span: decl_span,
             }),
         }),
         tokens: None,
@@ -322,7 +338,7 @@ pub(crate) fn eii_macro_for(
         false
     };
 
-    d.eii_macro_for = Some(EIIMacroFor { extern_item_path, impl_unsafe });
+    d.eii_macro_for = Some(EIIMacroFor { extern_item_path, impl_unsafe, span });
 
     // Return the original item and the new methods.
     vec![item]

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -1979,6 +1979,7 @@ fn add_post_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor
 /// used in any sections, so the linker will therefore pick relevant rlibs for linking, but
 /// unused `#[no_mangle]` or `#[used]` can still be discard by GC sections.
 ///
+// TODO: does EII solves this?
 /// There's a few internal crates in the standard library (aka libcore and
 /// libstd) which actually have a circular dependence upon one another. This
 /// currently arises through "weak lang items" where libcore requires things

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -99,6 +99,7 @@ fn reachable_non_generics_provider(tcx: TyCtxt<'_>, _: LocalCrate) -> DefIdMap<S
             // indicator
             if !Instance::mono(tcx, def_id.to_def_id()).def.generates_cgu_internal_copy(tcx)
                 || tcx.codegen_fn_attrs(def_id.to_def_id()).contains_extern_indicator()
+                || tcx.def_kind(def_id) == DefKind::EiiShim
             {
                 Some(def_id)
             } else {
@@ -435,7 +436,8 @@ fn upstream_monomorphizations_provider(
                 }
                 ExportedSymbol::NonGeneric(..)
                 | ExportedSymbol::ThreadLocalShim(..)
-                | ExportedSymbol::NoDefId(..) => {
+                | ExportedSymbol::NoDefId(..)
+                | ExportedSymbol::Alias { .. } => {
                     // These are no monomorphizations
                     continue;
                 }
@@ -581,6 +583,7 @@ pub(crate) fn symbol_name_for_instance_in_crate<'tcx>(
                 instantiating_crate,
             )
         }
+        ExportedSymbol::Alias { original: _, alternative_symbol } => alternative_symbol.to_string(),
         ExportedSymbol::NoDefId(symbol_name) => symbol_name.to_string(),
     }
 }
@@ -607,6 +610,10 @@ fn calling_convention_for_symbol<'tcx>(
         ExportedSymbol::NoDefId(..) => None,
         // ThreadLocalShim always follow the target's default symbol decoration scheme.
         ExportedSymbol::ThreadLocalShim(..) => None,
+        // Aliases have the same calling convention as the thing they alias.
+        ExportedSymbol::Alias { original, alternative_symbol: _ } => {
+            Some(Instance::mono(tcx, original))
+        }
     };
 
     instance