error on invalid macho section specifier

Author: folkertdev

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -497,7 +497,7 @@ impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
             return None;
         }
 
-        Some(LinkSection { name, span: cx.attr_span })
+        Some(LinkSection { name, name_span: nv.value_span, span: cx.attr_span })
     }
 }
 

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -1229,8 +1229,9 @@ pub enum AttributeKind {
 
     /// Represents [`#[link_section]`](https://doc.rust-lang.org/reference/abi.html#the-link_section-attribute)
     LinkSection {
-        name: Symbol,
         span: Span,
+        name: Symbol,
+        name_span: Span,
     },
 
     /// Represents `#[linkage]`.

compiler/rustc_passes/src/check_attr.rs

@@ -43,6 +43,7 @@ use rustc_session::lint::builtin::{
 use rustc_session::parse::feature_err;
 use rustc_span::edition::Edition;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, sym};
+use rustc_target::spec::BinaryFormat;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::infer::{TyCtxtInferExt, ValuePairs};
 use rustc_trait_selection::traits::ObligationCtxt;
@@ -199,6 +200,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 Attribute::Parsed(AttributeKind::Link(_, attr_span)) => {
                     self.check_link(hir_id, *attr_span, span, target)
                 },
+                Attribute::Parsed(AttributeKind::LinkSection { span: _, name, name_span }) => {
+                    self.check_link_section(*name, *name_span)
+                },
                 Attribute::Parsed(AttributeKind::MacroExport { span, .. }) => {
                     self.check_macro_export(hir_id, *span, target)
                 },
@@ -249,7 +253,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     | AttributeKind::Lang(..)
                     | AttributeKind::LinkName { .. }
                     | AttributeKind::LinkOrdinal { .. }
-                    | AttributeKind::LinkSection { .. }
                     | AttributeKind::Linkage(..)
                     | AttributeKind::MacroEscape( .. )
                     | AttributeKind::MacroUse { .. }
@@ -1196,6 +1199,46 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         );
     }
 
+    /// Checks if `#[link_section]` has a valid argument.
+    fn check_link_section(&self, name: Symbol, name_span: Span) {
+        // We (currently) only validate macho section specifiers.
+        match self.tcx.sess.target.binary_format {
+            BinaryFormat::MachO => match Self::check_link_section_macho(name) {
+                Ok(()) => {}
+                Err(reason) => {
+                    let err = errors::InvalidMachoSection { name_span, reason };
+                    self.tcx.dcx().emit_err(err);
+                }
+            },
+            BinaryFormat::Coff | BinaryFormat::Elf | BinaryFormat::Wasm | BinaryFormat::Xcoff => {}
+        }
+    }
+
+    fn check_link_section_macho(name: Symbol) -> Result<(), errors::InvalidMachoSectionReason> {
+        use errors::InvalidMachoSectionReason as Reason;
+
+        let mut parts = name.as_str().split(',').map(|s| s.trim());
+
+        // The segment can be empty.
+        let _segment = parts.next();
+
+        // But the section is required.
+        let section = match parts.next() {
+            None | Some("") => return Err(Reason::MissingSection),
+            Some(section) => section,
+        };
+
+        if section.len() > 16 {
+            return Err(Reason::SectionTooLong { section: section.to_string() });
+        }
+
+        // LLVM also checks the other components of the section specifier, but that logic is hard to
+        // keep in sync. We skip it here for now, assuming that if you got that far you'll be able
+        // to interpret the LLVM errors.
+
+        Ok(())
+    }
+
     /// Checks if `#[rustc_legacy_const_generics]` is applied to a function and has a valid argument.
     fn check_rustc_legacy_const_generics(
         &self,

compiler/rustc_passes/src/errors.rs

@@ -1332,3 +1332,22 @@ pub(crate) struct UnknownFormatParameterForOnUnimplementedAttr {
 pub(crate) struct OnMoveMalformedFormatLiterals {
     pub name: Symbol,
 }
+
+#[derive(Diagnostic)]
+#[diag("invalid macho section specifier")]
+pub(crate) struct InvalidMachoSection {
+    #[primary_span]
+    #[label("not a valid macho section specifier")]
+    pub name_span: Span,
+    #[subdiagnostic]
+    pub reason: InvalidMachoSectionReason,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum InvalidMachoSectionReason {
+    #[note("a macho section specifier requires a segment and a section, separated by a comma")]
+    #[help("an example of a valid macho section specifier is `__TEXT,__cstring`")]
+    MissingSection,
+    #[note("section name `{$section}` is longer than 16 bytes")]
+    SectionTooLong { section: String },
+}

tests/ui/linkage-attr/link-section-macho.rs

@@ -0,0 +1,54 @@
+//@ add-minicore
+//@ compile-flags: --target aarch64-apple-darwin
+//@ needs-llvm-components: aarch64
+//@ ignore-backends: gcc
+#![feature(no_core, rustc_attrs, lang_items)]
+#![no_core]
+#![crate_type = "lib"]
+
+extern crate minicore;
+use minicore::*;
+
+#[unsafe(link_section = "foo")]
+//~^ ERROR invalid macho section specifier
+#[unsafe(no_mangle)]
+fn missing_section() {}
+
+#[unsafe(link_section = "foo,")]
+//~^ ERROR invalid macho section specifier
+#[unsafe(no_mangle)]
+fn empty_section() {}
+
+#[unsafe(link_section = "foo, ")]
+//~^ ERROR invalid macho section specifier
+#[unsafe(no_mangle)]
+fn whitespace_section() {}
+
+#[unsafe(link_section = "foo,somelongwindedthing")]
+//~^ ERROR invalid macho section specifier
+#[unsafe(no_mangle)]
+fn section_too_long() {}
+
+#[unsafe(link_section = "foo,bar")]
+#[unsafe(no_mangle)]
+fn segment_and_section() {}
+
+#[unsafe(link_section = "foo,bar,")]
+#[unsafe(no_mangle)]
+fn segment_and_section_and_comma() {}
+
+#[unsafe(link_section = ",foo")]
+#[unsafe(no_mangle)]
+fn missing_segment_is_fine() {}
+
+#[unsafe(link_section = "__TEXT,__stubs,symbol_stubs,none,16")]
+#[unsafe(no_mangle)]
+fn stub_size_decimal() {}
+
+#[unsafe(link_section = "__TEXT,__stubs,symbol_stubs,none,0x10")]
+#[unsafe(no_mangle)]
+fn stub_size_hex() {}
+
+#[unsafe(link_section = "__TEXT,__stubs,symbol_stubs,none,020")]
+#[unsafe(no_mangle)]
+fn stub_size_oct() {}

tests/ui/linkage-attr/link-section-macho.stderr

@@ -0,0 +1,37 @@
+error: invalid macho section specifier
+  --> $DIR/link-section-macho.rs:12:25
+   |
+LL | #[unsafe(link_section = "foo")]
+   |                         ^^^^^ not a valid macho section specifier
+   |
+   = note: a macho section specifier requires a segment and a section, separated by a comma
+   = help: an example of a valid macho section specifier is `__TEXT,__cstring`
+
+error: invalid macho section specifier
+  --> $DIR/link-section-macho.rs:17:25
+   |
+LL | #[unsafe(link_section = "foo,")]
+   |                         ^^^^^^ not a valid macho section specifier
+   |
+   = note: a macho section specifier requires a segment and a section, separated by a comma
+   = help: an example of a valid macho section specifier is `__TEXT,__cstring`
+
+error: invalid macho section specifier
+  --> $DIR/link-section-macho.rs:22:25
+   |
+LL | #[unsafe(link_section = "foo, ")]
+   |                         ^^^^^^^ not a valid macho section specifier
+   |
+   = note: a macho section specifier requires a segment and a section, separated by a comma
+   = help: an example of a valid macho section specifier is `__TEXT,__cstring`
+
+error: invalid macho section specifier
+  --> $DIR/link-section-macho.rs:27:25
+   |
+LL | #[unsafe(link_section = "foo,somelongwindedthing")]
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ not a valid macho section specifier
+   |
+   = note: section name `somelongwindedthing` is longer than 16 bytes
+
+error: aborting due to 4 previous errors
+