bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #109091 - Nilstrieb:match-on-attr, r=cjgillot

Browse source 
Cleanup `codegen_fn_attrs`

The `match` control flow construct has been stable since 1.0, we should use it here.

Sorry for the hard to review diff, I did try to at least split it into two commits. But looking at before-after side-by-side (instead of whatever github is doing) is probably the easiest way to make sure that I didn't forget about anything.

On top of #109088, you can wait for that
This commit is contained in:
bors 2023-03-27 05:01:19 +00:00
commit 7a0600714a
1 changed files with 332 additions and 299 deletions
Download patch file Download diff file Expand all files Collapse all files

143
compiler/rustc_codegen_ssa/src/codegen_attrs.rs
View file

@ -10,6 +10,7 @@ use rustc_middle::mir::mono::Linkage;
use rustc_middle::ty::query::Providers; use rustc_middle::ty::query::Providers;
use rustc_middle::ty::{self as ty, TyCtxt}; use rustc_middle::ty::{self as ty, TyCtxt};
use rustc_session::{lint, parse::feature_err}; use rustc_session::{lint, parse::feature_err};
use rustc_span::symbol::Ident;
use rustc_span::{sym, Span}; use rustc_span::{sym, Span};
use rustc_target::spec::{abi, SanitizerSet}; use rustc_target::spec::{abi, SanitizerSet};
@ -83,33 +84,51 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
} }
}; };
if attr.has_name(sym::cold) { let Some(Ident { name, .. }) = attr.ident() else {
continue;
};
match name {
sym::cold => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::COLD; codegen_fn_attrs.flags |= CodegenFnAttrFlags::COLD;
} else if attr.has_name(sym::rustc_allocator) { }
sym::rustc_allocator => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR; codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR;
} else if attr.has_name(sym::ffi_returns_twice) { }
sym::ffi_returns_twice => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_RETURNS_TWICE; codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_RETURNS_TWICE;
} else if attr.has_name(sym::ffi_pure) { }
sym::ffi_pure => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE; codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_PURE;
} else if attr.has_name(sym::ffi_const) { }
sym::ffi_const => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST; codegen_fn_attrs.flags |= CodegenFnAttrFlags::FFI_CONST;
} else if attr.has_name(sym::rustc_nounwind) { }
sym::rustc_nounwind => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NEVER_UNWIND; codegen_fn_attrs.flags |= CodegenFnAttrFlags::NEVER_UNWIND;
} else if attr.has_name(sym::rustc_reallocator) { }
sym::rustc_reallocator => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::REALLOCATOR; codegen_fn_attrs.flags |= CodegenFnAttrFlags::REALLOCATOR;
} else if attr.has_name(sym::rustc_deallocator) { }
sym::rustc_deallocator => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::DEALLOCATOR; codegen_fn_attrs.flags |= CodegenFnAttrFlags::DEALLOCATOR;
} else if attr.has_name(sym::rustc_allocator_zeroed) { }
sym::rustc_allocator_zeroed => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR_ZEROED; codegen_fn_attrs.flags |= CodegenFnAttrFlags::ALLOCATOR_ZEROED;
} else if attr.has_name(sym::naked) { }
sym::naked => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED; codegen_fn_attrs.flags |= CodegenFnAttrFlags::NAKED;
} else if attr.has_name(sym::no_mangle) { }
sym::no_mangle => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE; codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
} else if attr.has_name(sym::no_coverage) { }
sym::no_coverage => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_COVERAGE; codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_COVERAGE;
} else if attr.has_name(sym::rustc_std_internal_symbol) { }
sym::rustc_std_internal_symbol => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL; codegen_fn_attrs.flags |= CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL;
} else if attr.has_name(sym::used) { }
sym::used => {
let inner = attr.meta_item_list(); let inner = attr.meta_item_list();
match inner.as_deref() { match inner.as_deref() {
Some([item]) if item.has_name(sym::linker) => { Some([item]) if item.has_name(sym::linker) => {
@ -171,7 +190,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
}; };
} }
} }
} else if attr.has_name(sym::cmse_nonsecure_entry) { }
sym::cmse_nonsecure_entry => {
if let Some(fn_sig) = fn_sig() if let Some(fn_sig) = fn_sig()
&& !matches!(fn_sig.skip_binder().abi(), abi::Abi::C { .. }) && !matches!(fn_sig.skip_binder().abi(), abi::Abi::C { .. })
{ {
@ -188,9 +208,11 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
.emit(); .emit();
} }
codegen_fn_attrs.flags |= CodegenFnAttrFlags::CMSE_NONSECURE_ENTRY; codegen_fn_attrs.flags |= CodegenFnAttrFlags::CMSE_NONSECURE_ENTRY;
} else if attr.has_name(sym::thread_local) { }
sym::thread_local => {
codegen_fn_attrs.flags |= CodegenFnAttrFlags::THREAD_LOCAL; codegen_fn_attrs.flags |= CodegenFnAttrFlags::THREAD_LOCAL;
} else if attr.has_name(sym::track_caller) { }
sym::track_caller => {
if !tcx.is_closure(did.to_def_id()) if !tcx.is_closure(did.to_def_id())
&& let Some(fn_sig) = fn_sig() && let Some(fn_sig) = fn_sig()
&& fn_sig.skip_binder().abi() != abi::Abi::Rust && fn_sig.skip_binder().abi() != abi::Abi::Rust
@ -208,7 +230,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
.emit(); .emit();
} }
codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER; codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER;
} else if attr.has_name(sym::export_name) { }
sym::export_name => {
if let Some(s) = attr.value_str() { if let Some(s) = attr.value_str() {
if s.as_str().contains('\0') { if s.as_str().contains('\0') {
// `#[export_name = ...]` will be converted to a null-terminated string, // `#[export_name = ...]` will be converted to a null-terminated string,
@ -223,7 +246,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
} }
codegen_fn_attrs.export_name = Some(s); codegen_fn_attrs.export_name = Some(s);
} }
} else if attr.has_name(sym::target_feature) { }
sym::target_feature => {
if !tcx.is_closure(did.to_def_id()) if !tcx.is_closure(did.to_def_id())
&& let Some(fn_sig) = fn_sig() && let Some(fn_sig) = fn_sig()
&& fn_sig.skip_binder().unsafety() == hir::Unsafety::Normal && fn_sig.skip_binder().unsafety() == hir::Unsafety::Normal
@ -268,7 +292,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
supported_target_features, supported_target_features,
&mut codegen_fn_attrs.target_features, &mut codegen_fn_attrs.target_features,
); );
} else if attr.has_name(sym::linkage) { }
sym::linkage => {
if let Some(val) = attr.value_str() { if let Some(val) = attr.value_str() {
let linkage = Some(linkage_by_name(tcx, did, val.as_str())); let linkage = Some(linkage_by_name(tcx, did, val.as_str()));
if tcx.is_foreign_item(did) { if tcx.is_foreign_item(did) {
@ -277,7 +302,8 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
codegen_fn_attrs.linkage = linkage; codegen_fn_attrs.linkage = linkage;
} }
} }
} else if attr.has_name(sym::link_section) { }
sym::link_section => {
if let Some(val) = attr.value_str() { if let Some(val) = attr.value_str() {
if val.as_str().bytes().any(|b| b == 0) { if val.as_str().bytes().any(|b| b == 0) {
let msg = format!( let msg = format!(
@ -290,35 +316,47 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
codegen_fn_attrs.link_section = Some(val); codegen_fn_attrs.link_section = Some(val);
} }
} }
} else if attr.has_name(sym::link_name) { }
sym::link_name => {
codegen_fn_attrs.link_name = attr.value_str(); codegen_fn_attrs.link_name = attr.value_str();
} else if attr.has_name(sym::link_ordinal) { }
sym::link_ordinal => {
link_ordinal_span = Some(attr.span); link_ordinal_span = Some(attr.span);
if let ordinal @ Some(_) = check_link_ordinal(tcx, attr) { if let ordinal @ Some(_) = check_link_ordinal(tcx, attr) {
codegen_fn_attrs.link_ordinal = ordinal; codegen_fn_attrs.link_ordinal = ordinal;
} }
} else if attr.has_name(sym::no_sanitize) { }
sym::no_sanitize => {
no_sanitize_span = Some(attr.span); no_sanitize_span = Some(attr.span);
if let Some(list) = attr.meta_item_list() { if let Some(list) = attr.meta_item_list() {
for item in list.iter() { for item in list.iter() {
if item.has_name(sym::address) { match item.ident().map(|ident| ident.name) {
Some(sym::address) => {
codegen_fn_attrs.no_sanitize |= codegen_fn_attrs.no_sanitize |=
SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS; SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS;
} else if item.has_name(sym::cfi) { }
Some(sym::cfi) => {
codegen_fn_attrs.no_sanitize |= SanitizerSet::CFI; codegen_fn_attrs.no_sanitize |= SanitizerSet::CFI;
} else if item.has_name(sym::kcfi) { }
Some(sym::kcfi) => {
codegen_fn_attrs.no_sanitize |= SanitizerSet::KCFI; codegen_fn_attrs.no_sanitize |= SanitizerSet::KCFI;
} else if item.has_name(sym::memory) { }
Some(sym::memory) => {
codegen_fn_attrs.no_sanitize |= SanitizerSet::MEMORY; codegen_fn_attrs.no_sanitize |= SanitizerSet::MEMORY;
} else if item.has_name(sym::memtag) { }
Some(sym::memtag) => {
codegen_fn_attrs.no_sanitize |= SanitizerSet::MEMTAG; codegen_fn_attrs.no_sanitize |= SanitizerSet::MEMTAG;
} else if item.has_name(sym::shadow_call_stack) { }
Some(sym::shadow_call_stack) => {
codegen_fn_attrs.no_sanitize |= SanitizerSet::SHADOWCALLSTACK; codegen_fn_attrs.no_sanitize |= SanitizerSet::SHADOWCALLSTACK;
} else if item.has_name(sym::thread) { }
Some(sym::thread) => {
codegen_fn_attrs.no_sanitize |= SanitizerSet::THREAD; codegen_fn_attrs.no_sanitize |= SanitizerSet::THREAD;
} else if item.has_name(sym::hwaddress) { }
Some(sym::hwaddress) => {
codegen_fn_attrs.no_sanitize |= SanitizerSet::HWADDRESS; codegen_fn_attrs.no_sanitize |= SanitizerSet::HWADDRESS;
} else { }
_ => {
tcx.sess tcx.sess
.struct_span_err(item.span(), "invalid argument for `no_sanitize`") .struct_span_err(item.span(), "invalid argument for `no_sanitize`")
.note("expected one of: `address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow-call-stack`, or `thread`") .note("expected one of: `address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow-call-stack`, or `thread`")
@ -326,8 +364,11 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
} }
} }
} }
} else if attr.has_name(sym::instruction_set) { }
codegen_fn_attrs.instruction_set = attr.meta_item_list().and_then(|l| match &l[..] { }
sym::instruction_set => {
codegen_fn_attrs.instruction_set =
attr.meta_item_list().and_then(|l| match &l[..] {
[NestedMetaItem::MetaItem(set)] => { [NestedMetaItem::MetaItem(set)] => {
let segments = let segments =
set.path.segments.iter().map(|x| x.ident.name).collect::<Vec<_>>(); set.path.segments.iter().map(|x| x.ident.name).collect::<Vec<_>>();
@ -383,16 +424,13 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
None None
} }
}) })
} else if attr.has_name(sym::repr) { }
codegen_fn_attrs.alignment = match attr.meta_item_list() { sym::repr => {
Some(items) => match items.as_slice() { codegen_fn_attrs.alignment = if let Some(items) = attr.meta_item_list()
[item] => match item.name_value_literal() { && let [item] = items.as_slice()
Some((sym::align, literal)) => { && let Some((sym::align, literal)) = item.name_value_literal()
let alignment = rustc_attr::parse_alignment(&literal.kind); {
rustc_attr::parse_alignment(&literal.kind).map_err(|msg| {
match alignment {
Ok(align) => Some(align),
Err(msg) => {
struct_span_err!( struct_span_err!(
tcx.sess.diagnostic(), tcx.sess.diagnostic(),
attr.span, attr.span,
@ -401,19 +439,14 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
msg msg
) )
.emit(); .emit();
})
.ok()
} else {
None None
}
}
}
_ => None,
},
[] => None,
_ => None,
},
None => None,
}; };
} }
_ => {}
}
} }
codegen_fn_attrs.inline = attrs.iter().fold(InlineAttr::None, |ia, attr| { codegen_fn_attrs.inline = attrs.iter().fold(InlineAttr::None, |ia, attr| {