rustc_builtin_macros/
asm.rs

1use rustc_ast::tokenstream::TokenStream;
2use rustc_ast::{AsmMacro, token};
3use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
4use rustc_errors::PResult;
5use rustc_expand::base::*;
6use rustc_index::bit_set::GrowableBitSet;
7use rustc_parse::parser::asm::*;
8use rustc_session::lint;
9use rustc_session::parse::feature_err;
10use rustc_span::{ErrorGuaranteed, InnerSpan, Span, Symbol, sym};
11use rustc_target::asm::InlineAsmArch;
12use smallvec::smallvec;
13use {rustc_ast as ast, rustc_parse_format as parse};
14
15use crate::util::{ExprToSpannedString, expr_to_spanned_string};
16use crate::{errors, fluent_generated as fluent};
17
18/// Validated assembly arguments, ready for macro expansion.
19struct ValidatedAsmArgs {
20    pub templates: Vec<Box<ast::Expr>>,
21    pub operands: Vec<(ast::InlineAsmOperand, Span)>,
22    named_args: FxIndexMap<Symbol, usize>,
23    reg_args: GrowableBitSet<usize>,
24    pub clobber_abis: Vec<(Symbol, Span)>,
25    options: ast::InlineAsmOptions,
26    pub options_spans: Vec<Span>,
27}
28
29fn parse_args<'a>(
30    ecx: &ExtCtxt<'a>,
31    sp: Span,
32    tts: TokenStream,
33    asm_macro: AsmMacro,
34) -> PResult<'a, ValidatedAsmArgs> {
35    let args = parse_asm_args(&mut ecx.new_parser_from_tts(tts), sp, asm_macro)?;
36    validate_asm_args(ecx, asm_macro, args)
37}
38
39fn validate_asm_args<'a>(
40    ecx: &ExtCtxt<'a>,
41    asm_macro: AsmMacro,
42    args: Vec<AsmArg>,
43) -> PResult<'a, ValidatedAsmArgs> {
44    let dcx = ecx.dcx();
45
46    let strip_unconfigured = rustc_expand::config::StripUnconfigured {
47        sess: ecx.sess,
48        features: Some(ecx.ecfg.features),
49        config_tokens: false,
50        lint_node_id: ecx.current_expansion.lint_node_id,
51    };
52
53    let mut validated = ValidatedAsmArgs {
54        templates: vec![],
55        operands: vec![],
56        named_args: Default::default(),
57        reg_args: Default::default(),
58        clobber_abis: Vec::new(),
59        options: ast::InlineAsmOptions::empty(),
60        options_spans: vec![],
61    };
62
63    let mut allow_templates = true;
64
65    for arg in args {
66        for attr in arg.attributes.0.iter() {
67            match attr.name() {
68                Some(sym::cfg | sym::cfg_attr) => {
69                    if !ecx.ecfg.features.asm_cfg() {
70                        let span = attr.span();
71                        feature_err(ecx.sess, sym::asm_cfg, span, fluent::builtin_macros_asm_cfg)
72                            .emit();
73                    }
74                }
75                _ => {
76                    ecx.dcx().emit_err(errors::AsmAttributeNotSupported { span: attr.span() });
77                }
78            }
79        }
80
81        // Skip arguments that are configured out.
82        if ecx.ecfg.features.asm_cfg() && strip_unconfigured.configure(arg.attributes).is_none() {
83            continue;
84        }
85
86        match arg.kind {
87            AsmArgKind::Template(template) => {
88                // The error for the first template is delayed.
89                if !allow_templates {
90                    match template.kind {
91                        ast::ExprKind::Lit(token_lit)
92                            if matches!(
93                                token_lit.kind,
94                                token::LitKind::Str | token::LitKind::StrRaw(_)
95                            ) => {}
96                        ast::ExprKind::MacCall(..) => {}
97                        _ => {
98                            let err = dcx.create_err(errors::AsmExpectedOther {
99                                span: template.span,
100                                is_inline_asm: matches!(asm_macro, AsmMacro::Asm),
101                            });
102                            return Err(err);
103                        }
104                    }
105                }
106
107                validated.templates.push(template);
108            }
109            AsmArgKind::Operand(name, op) => {
110                allow_templates = false;
111
112                let explicit_reg = matches!(op.reg(), Some(ast::InlineAsmRegOrRegClass::Reg(_)));
113                let span = arg.span;
114                let slot = validated.operands.len();
115                validated.operands.push((op, span));
116
117                // Validate the order of named, positional & explicit register operands and
118                // clobber_abi/options. We do this at the end once we have the full span
119                // of the argument available.
120
121                if explicit_reg {
122                    if name.is_some() {
123                        dcx.emit_err(errors::AsmExplicitRegisterName { span });
124                    }
125                    validated.reg_args.insert(slot);
126                } else if let Some(name) = name {
127                    if let Some(&prev) = validated.named_args.get(&name) {
128                        dcx.emit_err(errors::AsmDuplicateArg {
129                            span,
130                            name,
131                            prev: validated.operands[prev].1,
132                        });
133                        continue;
134                    }
135                    validated.named_args.insert(name, slot);
136                } else if !validated.named_args.is_empty() || !validated.reg_args.is_empty() {
137                    let named =
138                        validated.named_args.values().map(|p| validated.operands[*p].1).collect();
139                    let explicit =
140                        validated.reg_args.iter().map(|p| validated.operands[p].1).collect();
141
142                    dcx.emit_err(errors::AsmPositionalAfter { span, named, explicit });
143                }
144            }
145            AsmArgKind::Options(new_options) => {
146                allow_templates = false;
147
148                for asm_option in new_options {
149                    let AsmOption { span, symbol, span_with_comma, options } = asm_option;
150
151                    if !asm_macro.is_supported_option(options) {
152                        // Tool-only output.
153                        dcx.emit_err(errors::AsmUnsupportedOption {
154                            span,
155                            symbol,
156                            span_with_comma,
157                            macro_name: asm_macro.macro_name(),
158                        });
159                    } else if validated.options.contains(options) {
160                        // Tool-only output.
161                        dcx.emit_err(errors::AsmOptAlreadyprovided {
162                            span,
163                            symbol,
164                            span_with_comma,
165                        });
166                    } else {
167                        validated.options |= asm_option.options;
168                    }
169                }
170
171                validated.options_spans.push(arg.span);
172            }
173            AsmArgKind::ClobberAbi(new_abis) => {
174                allow_templates = false;
175
176                match &new_abis[..] {
177                    // This should have errored above during parsing.
178                    [] => unreachable!(),
179                    [(abi, _span)] => validated.clobber_abis.push((*abi, arg.span)),
180                    _ => validated.clobber_abis.extend(new_abis),
181                }
182            }
183        }
184    }
185
186    if validated.options.contains(ast::InlineAsmOptions::NOMEM)
187        && validated.options.contains(ast::InlineAsmOptions::READONLY)
188    {
189        let spans = validated.options_spans.clone();
190        dcx.emit_err(errors::AsmMutuallyExclusive { spans, opt1: "nomem", opt2: "readonly" });
191    }
192    if validated.options.contains(ast::InlineAsmOptions::PURE)
193        && validated.options.contains(ast::InlineAsmOptions::NORETURN)
194    {
195        let spans = validated.options_spans.clone();
196        dcx.emit_err(errors::AsmMutuallyExclusive { spans, opt1: "pure", opt2: "noreturn" });
197    }
198    if validated.options.contains(ast::InlineAsmOptions::PURE)
199        && !validated
200            .options
201            .intersects(ast::InlineAsmOptions::NOMEM | ast::InlineAsmOptions::READONLY)
202    {
203        let spans = validated.options_spans.clone();
204        dcx.emit_err(errors::AsmPureCombine { spans });
205    }
206
207    let mut have_real_output = false;
208    let mut outputs_sp = vec![];
209    let mut regclass_outputs = vec![];
210    let mut labels_sp = vec![];
211    for (op, op_sp) in &validated.operands {
212        match op {
213            ast::InlineAsmOperand::Out { reg, expr, .. }
214            | ast::InlineAsmOperand::SplitInOut { reg, out_expr: expr, .. } => {
215                outputs_sp.push(*op_sp);
216                have_real_output |= expr.is_some();
217                if let ast::InlineAsmRegOrRegClass::RegClass(_) = reg {
218                    regclass_outputs.push(*op_sp);
219                }
220            }
221            ast::InlineAsmOperand::InOut { reg, .. } => {
222                outputs_sp.push(*op_sp);
223                have_real_output = true;
224                if let ast::InlineAsmRegOrRegClass::RegClass(_) = reg {
225                    regclass_outputs.push(*op_sp);
226                }
227            }
228            ast::InlineAsmOperand::Label { .. } => {
229                labels_sp.push(*op_sp);
230            }
231            _ => {}
232        }
233    }
234    if validated.options.contains(ast::InlineAsmOptions::PURE) && !have_real_output {
235        dcx.emit_err(errors::AsmPureNoOutput { spans: validated.options_spans.clone() });
236    }
237    if validated.options.contains(ast::InlineAsmOptions::NORETURN)
238        && !outputs_sp.is_empty()
239        && labels_sp.is_empty()
240    {
241        let err = dcx.create_err(errors::AsmNoReturn { outputs_sp });
242        // Bail out now since this is likely to confuse MIR
243        return Err(err);
244    }
245    if validated.options.contains(ast::InlineAsmOptions::MAY_UNWIND) && !labels_sp.is_empty() {
246        dcx.emit_err(errors::AsmMayUnwind { labels_sp });
247    }
248
249    if !validated.clobber_abis.is_empty() {
250        match asm_macro {
251            AsmMacro::GlobalAsm | AsmMacro::NakedAsm => {
252                let err = dcx.create_err(errors::AsmUnsupportedClobberAbi {
253                    spans: validated.clobber_abis.iter().map(|(_, span)| *span).collect(),
254                    macro_name: asm_macro.macro_name(),
255                });
256
257                // Bail out now since this is likely to confuse later stages
258                return Err(err);
259            }
260            AsmMacro::Asm => {
261                if !regclass_outputs.is_empty() {
262                    dcx.emit_err(errors::AsmClobberNoReg {
263                        spans: regclass_outputs,
264                        clobbers: validated.clobber_abis.iter().map(|(_, span)| *span).collect(),
265                    });
266                }
267            }
268        }
269    }
270
271    Ok(validated)
272}
273
274fn expand_preparsed_asm(
275    ecx: &mut ExtCtxt<'_>,
276    asm_macro: AsmMacro,
277    args: ValidatedAsmArgs,
278) -> ExpandResult<Result<ast::InlineAsm, ErrorGuaranteed>, ()> {
279    let mut template = vec![];
280    // Register operands are implicitly used since they are not allowed to be
281    // referenced in the template string.
282    let mut used = vec![false; args.operands.len()];
283    for pos in args.reg_args.iter() {
284        used[pos] = true;
285    }
286    let named_pos: FxHashMap<usize, Symbol> =
287        args.named_args.iter().map(|(&sym, &idx)| (idx, sym)).collect();
288    let mut line_spans = Vec::with_capacity(args.templates.len());
289    let mut curarg = 0;
290
291    let mut template_strs = Vec::with_capacity(args.templates.len());
292
293    for (i, template_expr) in args.templates.into_iter().enumerate() {
294        if i != 0 {
295            template.push(ast::InlineAsmTemplatePiece::String("\n".into()));
296        }
297
298        let msg = "asm template must be a string literal";
299        let template_sp = template_expr.span;
300        let template_is_mac_call = matches!(template_expr.kind, ast::ExprKind::MacCall(_));
301        let ExprToSpannedString {
302            symbol: template_str,
303            style: template_style,
304            span: template_span,
305            ..
306        } = {
307            let ExpandResult::Ready(mac) = expr_to_spanned_string(ecx, template_expr, msg) else {
308                return ExpandResult::Retry(());
309            };
310            match mac {
311                Ok(template_part) => template_part,
312                Err(err) => {
313                    return ExpandResult::Ready(Err(match err {
314                        Ok((err, _)) => err.emit(),
315                        Err(guar) => guar,
316                    }));
317                }
318            }
319        };
320
321        let str_style = match template_style {
322            ast::StrStyle::Cooked => None,
323            ast::StrStyle::Raw(raw) => Some(raw as usize),
324        };
325
326        let template_snippet = ecx.source_map().span_to_snippet(template_sp).ok();
327        template_strs.push((
328            template_str,
329            template_snippet.as_deref().map(Symbol::intern),
330            template_sp,
331        ));
332        let template_str = template_str.as_str();
333
334        if let Some(InlineAsmArch::X86 | InlineAsmArch::X86_64) = ecx.sess.asm_arch {
335            let find_span = |needle: &str| -> Span {
336                if let Some(snippet) = &template_snippet {
337                    if let Some(pos) = snippet.find(needle) {
338                        let end = pos
339                            + snippet[pos..]
340                                .find(|c| matches!(c, '\n' | ';' | '\\' | '"'))
341                                .unwrap_or(snippet[pos..].len() - 1);
342                        let inner = InnerSpan::new(pos, end);
343                        return template_sp.from_inner(inner);
344                    }
345                }
346                template_sp
347            };
348
349            if template_str.contains(".intel_syntax") {
350                ecx.psess().buffer_lint(
351                    lint::builtin::BAD_ASM_STYLE,
352                    find_span(".intel_syntax"),
353                    ecx.current_expansion.lint_node_id,
354                    errors::AvoidIntelSyntax,
355                );
356            }
357            if template_str.contains(".att_syntax") {
358                ecx.psess().buffer_lint(
359                    lint::builtin::BAD_ASM_STYLE,
360                    find_span(".att_syntax"),
361                    ecx.current_expansion.lint_node_id,
362                    errors::AvoidAttSyntax,
363                );
364            }
365        }
366
367        // Don't treat raw asm as a format string.
368        if args.options.contains(ast::InlineAsmOptions::RAW) {
369            template.push(ast::InlineAsmTemplatePiece::String(template_str.to_string().into()));
370            let template_num_lines = 1 + template_str.matches('\n').count();
371            line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
372            continue;
373        }
374
375        let mut parser = parse::Parser::new(
376            template_str,
377            str_style,
378            template_snippet,
379            false,
380            parse::ParseMode::InlineAsm,
381        );
382        parser.curarg = curarg;
383
384        let mut unverified_pieces = Vec::new();
385        while let Some(piece) = parser.next() {
386            if !parser.errors.is_empty() {
387                break;
388            } else {
389                unverified_pieces.push(piece);
390            }
391        }
392
393        if !parser.errors.is_empty() {
394            let err = parser.errors.remove(0);
395            let err_sp = if template_is_mac_call {
396                // If the template is a macro call we can't reliably point to the error's
397                // span so just use the template's span as the error span (fixes #129503)
398                template_span
399            } else {
400                template_span.from_inner(InnerSpan::new(err.span.start, err.span.end))
401            };
402
403            let msg = format!("invalid asm template string: {}", err.description);
404            let mut e = ecx.dcx().struct_span_err(err_sp, msg);
405            e.span_label(err_sp, err.label + " in asm template string");
406            if let Some(note) = err.note {
407                e.note(note);
408            }
409            if let Some((label, span)) = err.secondary_label {
410                let err_sp = template_span.from_inner(InnerSpan::new(span.start, span.end));
411                e.span_label(err_sp, label);
412            }
413            let guar = e.emit();
414            return ExpandResult::Ready(Err(guar));
415        }
416
417        curarg = parser.curarg;
418
419        let mut arg_spans = parser
420            .arg_places
421            .iter()
422            .map(|span| template_span.from_inner(InnerSpan::new(span.start, span.end)));
423        for piece in unverified_pieces {
424            match piece {
425                parse::Piece::Lit(s) => {
426                    template.push(ast::InlineAsmTemplatePiece::String(s.to_string().into()))
427                }
428                parse::Piece::NextArgument(arg) => {
429                    let span = arg_spans.next().unwrap_or(template_sp);
430
431                    let operand_idx = match arg.position {
432                        parse::ArgumentIs(idx) | parse::ArgumentImplicitlyIs(idx) => {
433                            if idx >= args.operands.len()
434                                || named_pos.contains_key(&idx)
435                                || args.reg_args.contains(idx)
436                            {
437                                let msg = format!("invalid reference to argument at index {idx}");
438                                let mut err = ecx.dcx().struct_span_err(span, msg);
439                                err.span_label(span, "from here");
440
441                                let positional_args = args.operands.len()
442                                    - args.named_args.len()
443                                    - args.reg_args.len();
444                                let positional = if positional_args != args.operands.len() {
445                                    "positional "
446                                } else {
447                                    ""
448                                };
449                                let msg = match positional_args {
450                                    0 => format!("no {positional}arguments were given"),
451                                    1 => format!("there is 1 {positional}argument"),
452                                    x => format!("there are {x} {positional}arguments"),
453                                };
454                                err.note(msg);
455
456                                if named_pos.contains_key(&idx) {
457                                    err.span_label(args.operands[idx].1, "named argument");
458                                    err.span_note(
459                                        args.operands[idx].1,
460                                        "named arguments cannot be referenced by position",
461                                    );
462                                } else if args.reg_args.contains(idx) {
463                                    err.span_label(
464                                        args.operands[idx].1,
465                                        "explicit register argument",
466                                    );
467                                    err.span_note(
468                                        args.operands[idx].1,
469                                        "explicit register arguments cannot be used in the asm template",
470                                    );
471                                    err.span_help(
472                                        args.operands[idx].1,
473                                        "use the register name directly in the assembly code",
474                                    );
475                                }
476                                err.emit();
477                                None
478                            } else {
479                                Some(idx)
480                            }
481                        }
482                        parse::ArgumentNamed(name) => {
483                            match args.named_args.get(&Symbol::intern(name)) {
484                                Some(&idx) => Some(idx),
485                                None => {
486                                    let span = arg.position_span;
487                                    ecx.dcx()
488                                        .create_err(errors::AsmNoMatchedArgumentName {
489                                            name: name.to_owned(),
490                                            span: template_span
491                                                .from_inner(InnerSpan::new(span.start, span.end)),
492                                        })
493                                        .emit();
494                                    None
495                                }
496                            }
497                        }
498                    };
499
500                    let mut chars = arg.format.ty.chars();
501                    let mut modifier = chars.next();
502                    if chars.next().is_some() {
503                        let span = arg
504                            .format
505                            .ty_span
506                            .map(|sp| template_sp.from_inner(InnerSpan::new(sp.start, sp.end)))
507                            .unwrap_or(template_sp);
508                        ecx.dcx().emit_err(errors::AsmModifierInvalid { span });
509                        modifier = None;
510                    }
511
512                    if let Some(operand_idx) = operand_idx {
513                        used[operand_idx] = true;
514                        template.push(ast::InlineAsmTemplatePiece::Placeholder {
515                            operand_idx,
516                            modifier,
517                            span,
518                        });
519                    }
520                }
521            }
522        }
523
524        if parser.line_spans.is_empty() {
525            let template_num_lines = 1 + template_str.matches('\n').count();
526            line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
527        } else {
528            line_spans.extend(
529                parser
530                    .line_spans
531                    .iter()
532                    .map(|span| template_span.from_inner(InnerSpan::new(span.start, span.end))),
533            );
534        };
535    }
536
537    let mut unused_operands = vec![];
538    let mut help_str = String::new();
539    for (idx, used) in used.into_iter().enumerate() {
540        if !used {
541            let msg = if let Some(sym) = named_pos.get(&idx) {
542                help_str.push_str(&format!(" {{{}}}", sym));
543                "named argument never used"
544            } else {
545                help_str.push_str(&format!(" {{{}}}", idx));
546                "argument never used"
547            };
548            unused_operands.push((args.operands[idx].1, msg));
549        }
550    }
551    match unused_operands[..] {
552        [] => {}
553        [(sp, msg)] => {
554            ecx.dcx()
555                .struct_span_err(sp, msg)
556                .with_span_label(sp, msg)
557                .with_help(format!(
558                    "if this argument is intentionally unused, \
559                     consider using it in an asm comment: `\"/*{help_str} */\"`"
560                ))
561                .emit();
562        }
563        _ => {
564            let mut err = ecx.dcx().struct_span_err(
565                unused_operands.iter().map(|&(sp, _)| sp).collect::<Vec<Span>>(),
566                "multiple unused asm arguments",
567            );
568            for (sp, msg) in unused_operands {
569                err.span_label(sp, msg);
570            }
571            err.help(format!(
572                "if these arguments are intentionally unused, \
573                 consider using them in an asm comment: `\"/*{help_str} */\"`"
574            ));
575            err.emit();
576        }
577    }
578
579    ExpandResult::Ready(Ok(ast::InlineAsm {
580        asm_macro,
581        template,
582        template_strs: template_strs.into_boxed_slice(),
583        operands: args.operands,
584        clobber_abis: args.clobber_abis,
585        options: args.options,
586        line_spans,
587    }))
588}
589
590pub(super) fn expand_asm<'cx>(
591    ecx: &'cx mut ExtCtxt<'_>,
592    sp: Span,
593    tts: TokenStream,
594) -> MacroExpanderResult<'cx> {
595    ExpandResult::Ready(match parse_args(ecx, sp, tts, AsmMacro::Asm) {
596        Ok(args) => {
597            let ExpandResult::Ready(mac) = expand_preparsed_asm(ecx, AsmMacro::Asm, args) else {
598                return ExpandResult::Retry(());
599            };
600            let expr = match mac {
601                Ok(inline_asm) => Box::new(ast::Expr {
602                    id: ast::DUMMY_NODE_ID,
603                    kind: ast::ExprKind::InlineAsm(Box::new(inline_asm)),
604                    span: sp,
605                    attrs: ast::AttrVec::new(),
606                    tokens: None,
607                }),
608                Err(guar) => DummyResult::raw_expr(sp, Some(guar)),
609            };
610            MacEager::expr(expr)
611        }
612        Err(err) => {
613            let guar = err.emit();
614            DummyResult::any(sp, guar)
615        }
616    })
617}
618
619pub(super) fn expand_naked_asm<'cx>(
620    ecx: &'cx mut ExtCtxt<'_>,
621    sp: Span,
622    tts: TokenStream,
623) -> MacroExpanderResult<'cx> {
624    ExpandResult::Ready(match parse_args(ecx, sp, tts, AsmMacro::NakedAsm) {
625        Ok(args) => {
626            let ExpandResult::Ready(mac) = expand_preparsed_asm(ecx, AsmMacro::NakedAsm, args)
627            else {
628                return ExpandResult::Retry(());
629            };
630            let expr = match mac {
631                Ok(inline_asm) => Box::new(ast::Expr {
632                    id: ast::DUMMY_NODE_ID,
633                    kind: ast::ExprKind::InlineAsm(Box::new(inline_asm)),
634                    span: sp,
635                    attrs: ast::AttrVec::new(),
636                    tokens: None,
637                }),
638                Err(guar) => DummyResult::raw_expr(sp, Some(guar)),
639            };
640            MacEager::expr(expr)
641        }
642        Err(err) => {
643            let guar = err.emit();
644            DummyResult::any(sp, guar)
645        }
646    })
647}
648
649pub(super) fn expand_global_asm<'cx>(
650    ecx: &'cx mut ExtCtxt<'_>,
651    sp: Span,
652    tts: TokenStream,
653) -> MacroExpanderResult<'cx> {
654    ExpandResult::Ready(match parse_args(ecx, sp, tts, AsmMacro::GlobalAsm) {
655        Ok(args) => {
656            let ExpandResult::Ready(mac) = expand_preparsed_asm(ecx, AsmMacro::GlobalAsm, args)
657            else {
658                return ExpandResult::Retry(());
659            };
660            match mac {
661                Ok(inline_asm) => MacEager::items(smallvec![Box::new(ast::Item {
662                    attrs: ast::AttrVec::new(),
663                    id: ast::DUMMY_NODE_ID,
664                    kind: ast::ItemKind::GlobalAsm(Box::new(inline_asm)),
665                    vis: ast::Visibility {
666                        span: sp.shrink_to_lo(),
667                        kind: ast::VisibilityKind::Inherited,
668                        tokens: None,
669                    },
670                    span: sp,
671                    tokens: None,
672                })]),
673                Err(guar) => DummyResult::any(sp, guar),
674            }
675        }
676        Err(err) => {
677            let guar = err.emit();
678            DummyResult::any(sp, guar)
679        }
680    })
681}
rustc_builtin_macros/asm.rs

rustc_builtin_macros/
asm.rs
