Skip to content

Commit 0b81c2e

Browse files
asquared31415asquared31415
committed
Move named_asm_labels to a HIR lint
1 parent f66e825 commit 0b81c2e

File tree

10 files changed

+304
-147
lines changed

10 files changed

+304
-147
lines changed

‎compiler/rustc_ast/src/ast.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2028,6 +2028,7 @@ pub enum InlineAsmOperand {
20282028
#[derive(Clone, Encodable, Decodable, Debug)]
20292029
pub struct InlineAsm {
20302030
pub template: Vec<InlineAsmTemplatePiece>,
2031+
pub template_strs: Box<[(Symbol, Option<Symbol>, Span)]>,
20312032
pub operands: Vec<(InlineAsmOperand, Span)>,
20322033
pub clobber_abi: Option<(Symbol, Span)>,
20332034
pub options: InlineAsmOptions,

‎compiler/rustc_ast/src/visit.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,20 +19,20 @@ use crate::token;
1919
use rustc_span::symbol::{Ident, Symbol};
2020
use rustc_span::Span;
2121

22-
#[derive(Copy, Clone, PartialEq)]
22+
#[derive(Copy, Clone, Debug, PartialEq)]
2323
pub enum AssocCtxt {
2424
Trait,
2525
Impl,
2626
}
2727

28-
#[derive(Copy, Clone, PartialEq)]
28+
#[derive(Copy, Clone, Debug, PartialEq)]
2929
pub enum FnCtxt {
3030
Free,
3131
Foreign,
3232
Assoc(AssocCtxt),
3333
}
3434

35-
#[derive(Copy, Clone)]
35+
#[derive(Copy, Clone, Debug)]
3636
pub enum FnKind<'a> {
3737
/// E.g., `fn foo()`, `fn foo(&self)`, or `extern "Abi" fn foo()`.
3838
Fn(FnCtxt, Ident, &'a FnSig, &'a Visibility, Option<&'a Block>),

‎compiler/rustc_ast_lowering/src/asm.rs

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -392,8 +392,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
392392

393393
let operands = self.arena.alloc_from_iter(operands);
394394
let template = self.arena.alloc_from_iter(asm.template.iter().cloned());
395+
let template_strs = self.arena.alloc_from_iter(asm.template_strs.iter().cloned());
395396
let line_spans = self.arena.alloc_slice(&asm.line_spans[..]);
396-
let hir_asm = hir::InlineAsm { template, operands, options: asm.options, line_spans };
397+
let hir_asm =
398+
hir::InlineAsm { template, template_strs, operands, options: asm.options, line_spans };
397399
self.arena.alloc(hir_asm)
398400
}
399401
}

‎compiler/rustc_builtin_macros/src/asm.rs

Lines changed: 14 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -7,10 +7,10 @@ use rustc_errors::{Applicability, DiagnosticBuilder};
77
use rustc_expand::base::{self, *};
88
use rustc_parse::parser::Parser;
99
use rustc_parse_format as parse;
10-
use rustc_session::lint::{self, BuiltinLintDiagnostics};
10+
use rustc_session::lint;
1111
use rustc_span::symbol::Ident;
1212
use rustc_span::symbol::{kw, sym, Symbol};
13-
use rustc_span::{InnerSpan, MultiSpan, Span};
13+
use rustc_span::{InnerSpan, Span};
1414
use rustc_target::asm::InlineAsmArch;
1515
use smallvec::smallvec;
1616

@@ -484,11 +484,7 @@ fn parse_reg<'a>(
484484
Ok(result)
485485
}
486486

487-
fn expand_preparsed_asm(
488-
ecx: &mut ExtCtxt<'_>,
489-
args: AsmArgs,
490-
is_local_asm: bool,
491-
) -> Option<ast::InlineAsm> {
487+
fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::InlineAsm> {
492488
let mut template = vec![];
493489
// Register operands are implicitly used since they are not allowed to be
494490
// referenced in the template string.
@@ -501,6 +497,8 @@ fn expand_preparsed_asm(
501497
let mut line_spans = Vec::with_capacity(args.templates.len());
502498
let mut curarg = 0;
503499

500+
let mut template_strs = Vec::with_capacity(args.templates.len());
501+
504502
for template_expr in args.templates.into_iter() {
505503
if !template.is_empty() {
506504
template.push(ast::InlineAsmTemplatePiece::String("\n".to_string()));
@@ -524,8 +522,13 @@ fn expand_preparsed_asm(
524522
ast::StrStyle::Raw(raw) => Some(raw as usize),
525523
};
526524

527-
let template_str = &template_str.as_str();
528525
let template_snippet = ecx.source_map().span_to_snippet(template_sp).ok();
526+
template_strs.push((
527+
template_str,
528+
template_snippet.as_ref().map(|s| Symbol::intern(s)),
529+
template_sp,
530+
));
531+
let template_str = &template_str.as_str();
529532

530533
if let Some(InlineAsmArch::X86 | InlineAsmArch::X86_64) = ecx.sess.asm_arch {
531534
let find_span = |needle: &str| -> Span {
@@ -560,72 +563,6 @@ fn expand_preparsed_asm(
560563
}
561564
}
562565

563-
// Lint against the use of named labels in inline `asm!` but not `global_asm!`
564-
if is_local_asm {
565-
let find_label_span = |needle: &str| -> Option<Span> {
566-
if let Some(snippet) = &template_snippet {
567-
if let Some(pos) = snippet.find(needle) {
568-
let end = pos
569-
+ &snippet[pos..]
570-
.find(|c| c == ':')
571-
.unwrap_or(snippet[pos..].len() - 1);
572-
let inner = InnerSpan::new(pos, end);
573-
return Some(template_sp.from_inner(inner));
574-
}
575-
}
576-
577-
None
578-
};
579-
580-
let mut found_labels = Vec::new();
581-
582-
// A semicolon might not actually be specified as a separator for all targets, but it seems like LLVM accepts it always
583-
let statements = template_str.split(|c| matches!(c, '\n' | ';'));
584-
for statement in statements {
585-
// If there's a comment, trim it from the statement
586-
let statement = statement.find("//").map_or(statement, |idx| &statement[..idx]);
587-
let mut start_idx = 0;
588-
for (idx, _) in statement.match_indices(':') {
589-
let possible_label = statement[start_idx..idx].trim();
590-
let mut chars = possible_label.chars();
591-
if let Some(c) = chars.next() {
592-
// A label starts with an alphabetic character or . or _ and continues with alphanumeric characters, _, or $
593-
if (c.is_alphabetic() || matches!(c, '.' | '_'))
594-
&& chars.all(|c| c.is_alphanumeric() || matches!(c, '_' | '$'))
595-
{
596-
found_labels.push(possible_label);
597-
} else {
598-
// If we encounter a non-label, there cannot be any further labels, so stop checking
599-
break;
600-
}
601-
} else {
602-
// Empty string means a leading ':' in this section, which is not a label
603-
break;
604-
}
605-
606-
start_idx = idx + 1;
607-
}
608-
}
609-
610-
if found_labels.len() > 0 {
611-
let spans =
612-
found_labels.into_iter().filter_map(find_label_span).collect::<Vec<Span>>();
613-
// If there were labels but we couldn't find a span, combine the warnings and use the template span
614-
let target_spans: MultiSpan =
615-
if spans.len() > 0 { spans.into() } else { template_sp.into() };
616-
ecx.parse_sess().buffer_lint_with_diagnostic(
617-
lint::builtin::NAMED_ASM_LABELS,
618-
target_spans,
619-
ecx.current_expansion.lint_node_id,
620-
"avoid using named labels in inline assembly",
621-
BuiltinLintDiagnostics::NamedAsmLabel(
622-
"only local labels of the form `<number>:` should be used in inline asm"
623-
.to_string(),
624-
),
625-
);
626-
}
627-
}
628-
629566
// Don't treat raw asm as a format string.
630567
if args.options.contains(ast::InlineAsmOptions::RAW) {
631568
template.push(ast::InlineAsmTemplatePiece::String(template_str.to_string()));
@@ -819,6 +756,7 @@ fn expand_preparsed_asm(
819756

820757
Some(ast::InlineAsm {
821758
template,
759+
template_strs: template_strs.into_boxed_slice(),
822760
operands: args.operands,
823761
clobber_abi: args.clobber_abi,
824762
options: args.options,
@@ -833,7 +771,7 @@ pub fn expand_asm<'cx>(
833771
) -> Box<dyn base::MacResult + 'cx> {
834772
match parse_args(ecx, sp, tts, false) {
835773
Ok(args) => {
836-
let expr = if let Some(inline_asm) = expand_preparsed_asm(ecx, args, true) {
774+
let expr = if let Some(inline_asm) = expand_preparsed_asm(ecx, args) {
837775
P(ast::Expr {
838776
id: ast::DUMMY_NODE_ID,
839777
kind: ast::ExprKind::InlineAsm(P(inline_asm)),
@@ -860,7 +798,7 @@ pub fn expand_global_asm<'cx>(
860798
) -> Box<dyn base::MacResult + 'cx> {
861799
match parse_args(ecx, sp, tts, true) {
862800
Ok(args) => {
863-
if let Some(inline_asm) = expand_preparsed_asm(ecx, args, false) {
801+
if let Some(inline_asm) = expand_preparsed_asm(ecx, args) {
864802
MacEager::items(smallvec![P(ast::Item {
865803
ident: Ident::invalid(),
866804
attrs: Vec::new(),

‎compiler/rustc_hir/src/hir.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2386,6 +2386,7 @@ impl<'hir> InlineAsmOperand<'hir> {
23862386
#[derive(Debug, HashStable_Generic)]
23872387
pub struct InlineAsm<'hir> {
23882388
pub template: &'hir [InlineAsmTemplatePiece],
2389+
pub template_strs: &'hir [(Symbol, Option<Symbol>, Span)],
23892390
pub operands: &'hir [(InlineAsmOperand<'hir>, Span)],
23902391
pub options: InlineAsmOptions,
23912392
pub line_spans: &'hir [Span],

‎compiler/rustc_lint/src/builtin.rs

Lines changed: 122 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -45,11 +45,11 @@ use rustc_middle::ty::print::with_no_trimmed_paths;
4545
use rustc_middle::ty::subst::{GenericArgKind, Subst};
4646
use rustc_middle::ty::Instance;
4747
use rustc_middle::ty::{self, layout::LayoutError, Ty, TyCtxt};
48-
use rustc_session::lint::FutureIncompatibilityReason;
48+
use rustc_session::lint::{BuiltinLintDiagnostics, FutureIncompatibilityReason};
4949
use rustc_span::edition::Edition;
5050
use rustc_span::source_map::Spanned;
5151
use rustc_span::symbol::{kw, sym, Ident, Symbol};
52-
use rustc_span::{BytePos, Span};
52+
use rustc_span::{BytePos, InnerSpan, MultiSpan, Span};
5353
use rustc_target::abi::{LayoutOf, VariantIdx};
5454
use rustc_trait_selection::traits::misc::can_type_implement_copy;
5555

@@ -3140,3 +3140,123 @@ impl<'tcx> LateLintPass<'tcx> for DerefNullPtr {
31403140
}
31413141
}
31423142
}
3143+
3144+
declare_lint! {
3145+
/// The `named_asm_labels` lint detects the use of named labels in the
3146+
/// inline `asm!` macro.
3147+
///
3148+
/// ### Example
3149+
///
3150+
/// ```rust,compile_fail
3151+
/// #![feature(asm)]
3152+
/// fn main() {
3153+
/// unsafe {
3154+
/// asm!("foo: bar");
3155+
/// }
3156+
/// }
3157+
/// ```
3158+
///
3159+
/// {{produces}}
3160+
///
3161+
/// ### Explanation
3162+
///
3163+
/// LLVM is allowed to duplicate inline assembly blocks for any
3164+
/// reason, for example when it is in a function that gets inlined. Because
3165+
/// of this, GNU assembler [local labels] *must* be used instead of labels
3166+
/// with a name. Using named labels might cause assembler or linker errors.
3167+
///
3168+
/// See the [unstable book] for more details.
3169+
///
3170+
/// [local labels]: https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-Labels
3171+
/// [unstable book]: https://doc.rust-lang.org/nightly/unstable-book/library-features/asm.html#labels
3172+
pub NAMED_ASM_LABELS,
3173+
Deny,
3174+
"named labels in inline assembly",
3175+
}
3176+
3177+
declare_lint_pass!(NamedAsmLabels => [NAMED_ASM_LABELS]);
3178+
3179+
impl<'tcx> LateLintPass<'tcx> for NamedAsmLabels {
3180+
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
3181+
if let hir::Expr {
3182+
kind: hir::ExprKind::InlineAsm(hir::InlineAsm { template_strs, .. }),
3183+
..
3184+
} = expr
3185+
{
3186+
for (template_sym, template_snippet, template_span) in template_strs.iter() {
3187+
let template_str = &template_sym.as_str();
3188+
let find_label_span = |needle: &str| -> Option<Span> {
3189+
if let Some(template_snippet) = template_snippet {
3190+
let snippet = template_snippet.as_str();
3191+
if let Some(pos) = snippet.find(needle) {
3192+
let end = pos
3193+
+ &snippet[pos..]
3194+
.find(|c| c == ':')
3195+
.unwrap_or(snippet[pos..].len() - 1);
3196+
let inner = InnerSpan::new(pos, end);
3197+
return Some(template_span.from_inner(inner));
3198+
}
3199+
}
3200+
3201+
None
3202+
};
3203+
3204+
let mut found_labels = Vec::new();
3205+
3206+
// A semicolon might not actually be specified as a separator for all targets, but it seems like LLVM accepts it always
3207+
let statements = template_str.split(|c| matches!(c, '\n' | ';'));
3208+
for statement in statements {
3209+
// If there's a comment, trim it from the statement
3210+
let statement = statement.find("//").map_or(statement, |idx| &statement[..idx]);
3211+
let mut start_idx = 0;
3212+
for (idx, _) in statement.match_indices(':') {
3213+
let possible_label = statement[start_idx..idx].trim();
3214+
let mut chars = possible_label.chars();
3215+
if let Some(c) = chars.next() {
3216+
// A label starts with an alphabetic character or . or _ and continues with alphanumeric characters, _, or $
3217+
if (c.is_alphabetic() || matches!(c, '.' | '_'))
3218+
&& chars.all(|c| c.is_alphanumeric() || matches!(c, '_' | '$'))
3219+
{
3220+
found_labels.push(possible_label);
3221+
} else {
3222+
// If we encounter a non-label, there cannot be any further labels, so stop checking
3223+
break;
3224+
}
3225+
} else {
3226+
// Empty string means a leading ':' in this section, which is not a label
3227+
break;
3228+
}
3229+
3230+
start_idx = idx + 1;
3231+
}
3232+
}
3233+
3234+
debug!("NamedAsmLabels::check_expr(): found_labels: {:#?}", &found_labels);
3235+
3236+
if found_labels.len() > 0 {
3237+
let spans = found_labels
3238+
.into_iter()
3239+
.filter_map(|label| find_label_span(label))
3240+
.collect::<Vec<Span>>();
3241+
// If there were labels but we couldn't find a span, combine the warnings and use the template span
3242+
let target_spans: MultiSpan =
3243+
if spans.len() > 0 { spans.into() } else { (*template_span).into() };
3244+
3245+
cx.lookup_with_diagnostics(
3246+
NAMED_ASM_LABELS,
3247+
Some(target_spans),
3248+
|diag| {
3249+
let mut err =
3250+
diag.build("avoid using named labels in inline assembly");
3251+
err.emit();
3252+
},
3253+
BuiltinLintDiagnostics::NamedAsmLabel(
3254+
"only local labels of the form `<number>:` should be used in inline asm"
3255+
.to_string(),
3256+
),
3257+
);
3258+
}
3259+
}
3260+
}
3261+
}
3262+
}

‎compiler/rustc_lint/src/lib.rs

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -168,6 +168,7 @@ macro_rules! late_lint_passes {
168168
NonPanicFmt: NonPanicFmt,
169169
NoopMethodCall: NoopMethodCall,
170170
InvalidAtomicOrdering: InvalidAtomicOrdering,
171+
NamedAsmLabels: NamedAsmLabels,
171172
]
172173
);
173174
};

‎compiler/rustc_lint_defs/src/builtin.rs

Lines changed: 0 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -2468,38 +2468,6 @@ declare_lint! {
24682468
"incorrect use of inline assembly",
24692469
}
24702470

2471-
declare_lint! {
2472-
/// The `named_asm_labels` lint detects the use of named labels in the
2473-
/// inline `asm!` macro.
2474-
///
2475-
/// ### Example
2476-
///
2477-
/// ```rust,compile_fail
2478-
/// fn main() {
2479-
/// unsafe {
2480-
/// asm!("foo: bar");
2481-
/// }
2482-
/// }
2483-
/// ```
2484-
///
2485-
/// {{produces}}
2486-
///
2487-
/// ### Explanation
2488-
///
2489-
/// LLVM is allowed to duplicate inline assembly blocks for any
2490-
/// reason, for example when it is in a function that gets inlined. Because
2491-
/// of this, GNU assembler [local labels] *must* be used instead of labels
2492-
/// with a name. Using named labels might cause assembler or linker errors.
2493-
///
2494-
/// See the [unstable book] for more details.
2495-
///
2496-
/// [local labels]: https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-Labels
2497-
/// [unstable book]: https://doc.rust-lang.org/nightly/unstable-book/library-features/asm.html#labels
2498-
pub NAMED_ASM_LABELS,
2499-
Deny,
2500-
"named labels in inline assembly",
2501-
}
2502-
25032471
declare_lint! {
25042472
/// The `unsafe_op_in_unsafe_fn` lint detects unsafe operations in unsafe
25052473
/// functions without an explicit unsafe block.
@@ -3020,7 +2988,6 @@ declare_lint_pass! {
30202988
INLINE_NO_SANITIZE,
30212989
BAD_ASM_STYLE,
30222990
ASM_SUB_REGISTER,
3023-
NAMED_ASM_LABELS,
30242991
UNSAFE_OP_IN_UNSAFE_FN,
30252992
INCOMPLETE_INCLUDE,
30262993
CENUM_IMPL_DROP_CAST,

0 commit comments

Comments
 (0)