3 use rustc_ast::token::{self, Delimiter};
4 use rustc_ast::tokenstream::TokenStream;
5 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
6 use rustc_errors::{Applicability, PResult};
7 use rustc_expand::base::{self, *};
8 use rustc_parse::parser::Parser;
9 use rustc_parse_format as parse;
10 use rustc_session::lint;
11 use rustc_session::parse::ParseSess;
12 use rustc_span::symbol::Ident;
13 use rustc_span::symbol::{kw, sym, Symbol};
14 use rustc_span::{InnerSpan, Span};
15 use rustc_target::asm::InlineAsmArch;
16 use smallvec::smallvec;
19 pub templates: Vec<P<ast::Expr>>,
20 pub operands: Vec<(ast::InlineAsmOperand, Span)>,
21 named_args: FxHashMap<Symbol, usize>,
22 reg_args: FxHashSet<usize>,
23 pub clobber_abis: Vec<(Symbol, Span)>,
24 options: ast::InlineAsmOptions,
25 pub options_spans: Vec<Span>,
29 ecx: &mut ExtCtxt<'a>,
33 ) -> PResult<'a, AsmArgs> {
34 let mut p = ecx.new_parser_from_tts(tts);
35 let sess = &ecx.sess.parse_sess;
36 parse_asm_args(&mut p, sess, sp, is_global_asm)
39 // Primarily public for rustfmt consumption.
40 // Internal consumers should continue to leverage `expand_asm`/`expand__global_asm`
41 pub fn parse_asm_args<'a>(
46 ) -> PResult<'a, AsmArgs> {
47 let diag = &sess.span_diagnostic;
49 if p.token == token::Eof {
50 return Err(diag.struct_span_err(sp, "requires at least a template string argument"));
53 let first_template = p.parse_expr()?;
54 let mut args = AsmArgs {
55 templates: vec![first_template],
57 named_args: FxHashMap::default(),
58 reg_args: FxHashSet::default(),
59 clobber_abis: Vec::new(),
60 options: ast::InlineAsmOptions::empty(),
61 options_spans: vec![],
64 let mut allow_templates = true;
65 while p.token != token::Eof {
66 if !p.eat(&token::Comma) {
68 // After a template string, we always expect *only* a comma...
69 let mut err = diag.struct_span_err(p.token.span, "expected token: `,`");
70 err.span_label(p.token.span, "expected `,`");
71 p.maybe_annotate_with_ascription(&mut err, false);
74 // ...after that delegate to `expect` to also include the other expected tokens.
75 return Err(p.expect(&token::Comma).err().unwrap());
78 if p.token == token::Eof {
80 } // accept trailing commas
83 if p.eat_keyword(sym::clobber_abi) {
84 parse_clobber_abi(p, &mut args)?;
85 allow_templates = false;
90 if p.eat_keyword(sym::options) {
91 parse_options(p, &mut args, is_global_asm)?;
92 allow_templates = false;
96 let span_start = p.token.span;
98 // Parse operand names
99 let name = if p.token.is_ident() && p.look_ahead(1, |t| *t == token::Eq) {
100 let (ident, _) = p.token.ident().unwrap();
102 p.expect(&token::Eq)?;
103 allow_templates = false;
109 let mut explicit_reg = false;
110 let op = if !is_global_asm && p.eat_keyword(kw::In) {
111 let reg = parse_reg(p, &mut explicit_reg)?;
112 if p.eat_keyword(kw::Underscore) {
113 let err = diag.struct_span_err(p.token.span, "_ cannot be used for input operands");
116 let expr = p.parse_expr()?;
117 ast::InlineAsmOperand::In { reg, expr }
118 } else if !is_global_asm && p.eat_keyword(sym::out) {
119 let reg = parse_reg(p, &mut explicit_reg)?;
120 let expr = if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
121 ast::InlineAsmOperand::Out { reg, expr, late: false }
122 } else if !is_global_asm && p.eat_keyword(sym::lateout) {
123 let reg = parse_reg(p, &mut explicit_reg)?;
124 let expr = if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
125 ast::InlineAsmOperand::Out { reg, expr, late: true }
126 } else if !is_global_asm && p.eat_keyword(sym::inout) {
127 let reg = parse_reg(p, &mut explicit_reg)?;
128 if p.eat_keyword(kw::Underscore) {
129 let err = diag.struct_span_err(p.token.span, "_ cannot be used for input operands");
132 let expr = p.parse_expr()?;
133 if p.eat(&token::FatArrow) {
135 if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
136 ast::InlineAsmOperand::SplitInOut { reg, in_expr: expr, out_expr, late: false }
138 ast::InlineAsmOperand::InOut { reg, expr, late: false }
140 } else if !is_global_asm && p.eat_keyword(sym::inlateout) {
141 let reg = parse_reg(p, &mut explicit_reg)?;
142 if p.eat_keyword(kw::Underscore) {
143 let err = diag.struct_span_err(p.token.span, "_ cannot be used for input operands");
146 let expr = p.parse_expr()?;
147 if p.eat(&token::FatArrow) {
149 if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
150 ast::InlineAsmOperand::SplitInOut { reg, in_expr: expr, out_expr, late: true }
152 ast::InlineAsmOperand::InOut { reg, expr, late: true }
154 } else if p.eat_keyword(kw::Const) {
155 let anon_const = p.parse_anon_const_expr()?;
156 ast::InlineAsmOperand::Const { anon_const }
157 } else if p.eat_keyword(sym::sym) {
158 let expr = p.parse_expr()?;
159 let ast::ExprKind::Path(qself, path) = &expr.kind else {
161 .struct_span_err(expr.span, "expected a path for argument to `sym`");
164 let sym = ast::InlineAsmSym {
165 id: ast::DUMMY_NODE_ID,
166 qself: qself.clone(),
169 ast::InlineAsmOperand::Sym { sym }
170 } else if allow_templates {
171 let template = p.parse_expr()?;
172 // If it can't possibly expand to a string, provide diagnostics here to include other
173 // things it could have been.
174 match template.kind {
175 ast::ExprKind::Lit(token_lit)
178 token::LitKind::Str | token::LitKind::StrRaw(_)
180 ast::ExprKind::MacCall(..) => {}
182 let errstr = if is_global_asm {
183 "expected operand, options, or additional template string"
185 "expected operand, clobber_abi, options, or additional template string"
187 let mut err = diag.struct_span_err(template.span, errstr);
188 err.span_label(template.span, errstr);
192 args.templates.push(template);
195 return p.unexpected();
198 allow_templates = false;
199 let span = span_start.to(p.prev_token.span);
200 let slot = args.operands.len();
201 args.operands.push((op, span));
203 // Validate the order of named, positional & explicit register operands and
204 // clobber_abi/options. We do this at the end once we have the full span
205 // of the argument available.
206 if !args.options_spans.is_empty() {
207 diag.struct_span_err(span, "arguments are not allowed after options")
208 .span_labels(args.options_spans.clone(), "previous options")
209 .span_label(span, "argument")
211 } else if let Some((_, abi_span)) = args.clobber_abis.last() {
212 diag.struct_span_err(span, "arguments are not allowed after clobber_abi")
213 .span_label(*abi_span, "clobber_abi")
214 .span_label(span, "argument")
219 diag.struct_span_err(span, "explicit register arguments cannot have names").emit();
221 args.reg_args.insert(slot);
222 } else if let Some(name) = name {
223 if let Some(&prev) = args.named_args.get(&name) {
224 diag.struct_span_err(span, &format!("duplicate argument named `{}`", name))
225 .span_label(args.operands[prev].1, "previously here")
226 .span_label(span, "duplicate argument")
230 if !args.reg_args.is_empty() {
231 let mut err = diag.struct_span_err(
233 "named arguments cannot follow explicit register arguments",
235 err.span_label(span, "named argument");
236 for pos in &args.reg_args {
237 err.span_label(args.operands[*pos].1, "explicit register argument");
241 args.named_args.insert(name, slot);
243 if !args.named_args.is_empty() || !args.reg_args.is_empty() {
244 let mut err = diag.struct_span_err(
246 "positional arguments cannot follow named arguments \
247 or explicit register arguments",
249 err.span_label(span, "positional argument");
250 for pos in args.named_args.values() {
251 err.span_label(args.operands[*pos].1, "named argument");
253 for pos in &args.reg_args {
254 err.span_label(args.operands[*pos].1, "explicit register argument");
261 if args.options.contains(ast::InlineAsmOptions::NOMEM)
262 && args.options.contains(ast::InlineAsmOptions::READONLY)
264 let spans = args.options_spans.clone();
265 diag.struct_span_err(spans, "the `nomem` and `readonly` options are mutually exclusive")
268 if args.options.contains(ast::InlineAsmOptions::PURE)
269 && args.options.contains(ast::InlineAsmOptions::NORETURN)
271 let spans = args.options_spans.clone();
272 diag.struct_span_err(spans, "the `pure` and `noreturn` options are mutually exclusive")
275 if args.options.contains(ast::InlineAsmOptions::PURE)
276 && !args.options.intersects(ast::InlineAsmOptions::NOMEM | ast::InlineAsmOptions::READONLY)
278 let spans = args.options_spans.clone();
279 diag.struct_span_err(
281 "the `pure` option must be combined with either `nomem` or `readonly`",
286 let mut have_real_output = false;
287 let mut outputs_sp = vec![];
288 let mut regclass_outputs = vec![];
289 for (op, op_sp) in &args.operands {
291 ast::InlineAsmOperand::Out { reg, expr, .. }
292 | ast::InlineAsmOperand::SplitInOut { reg, out_expr: expr, .. } => {
293 outputs_sp.push(*op_sp);
294 have_real_output |= expr.is_some();
295 if let ast::InlineAsmRegOrRegClass::RegClass(_) = reg {
296 regclass_outputs.push(*op_sp);
299 ast::InlineAsmOperand::InOut { reg, .. } => {
300 outputs_sp.push(*op_sp);
301 have_real_output = true;
302 if let ast::InlineAsmRegOrRegClass::RegClass(_) = reg {
303 regclass_outputs.push(*op_sp);
309 if args.options.contains(ast::InlineAsmOptions::PURE) && !have_real_output {
310 diag.struct_span_err(
311 args.options_spans.clone(),
312 "asm with the `pure` option must have at least one output",
316 if args.options.contains(ast::InlineAsmOptions::NORETURN) && !outputs_sp.is_empty() {
318 .struct_span_err(outputs_sp, "asm outputs are not allowed with the `noreturn` option");
320 // Bail out now since this is likely to confuse MIR
324 if args.clobber_abis.len() > 0 {
326 let err = diag.struct_span_err(
327 args.clobber_abis.iter().map(|(_, span)| *span).collect::<Vec<Span>>(),
328 "`clobber_abi` cannot be used with `global_asm!`",
331 // Bail out now since this is likely to confuse later stages
334 if !regclass_outputs.is_empty() {
335 diag.struct_span_err(
336 regclass_outputs.clone(),
337 "asm with `clobber_abi` must specify explicit registers for outputs",
340 args.clobber_abis.iter().map(|(_, span)| *span).collect::<Vec<Span>>(),
343 .span_labels(regclass_outputs, "generic outputs")
351 /// Report a duplicate option error.
353 /// This function must be called immediately after the option token is parsed.
354 /// Otherwise, the suggestion will be incorrect.
355 fn err_duplicate_option(p: &mut Parser<'_>, symbol: Symbol, span: Span) {
359 .struct_span_err(span, &format!("the `{}` option was already provided", symbol));
360 err.span_label(span, "this option was already provided");
363 let mut full_span = span;
364 if p.token.kind == token::Comma {
365 full_span = full_span.to(p.token.span);
367 err.tool_only_span_suggestion(
369 "remove this option",
371 Applicability::MachineApplicable,
377 /// Try to set the provided option in the provided `AsmArgs`.
378 /// If it is already set, report a duplicate option error.
380 /// This function must be called immediately after the option token is parsed.
381 /// Otherwise, the error will not point to the correct spot.
382 fn try_set_option<'a>(
386 option: ast::InlineAsmOptions,
388 if !args.options.contains(option) {
389 args.options |= option;
391 err_duplicate_option(p, symbol, p.prev_token.span);
395 fn parse_options<'a>(
399 ) -> PResult<'a, ()> {
400 let span_start = p.prev_token.span;
402 p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
404 while !p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
405 if !is_global_asm && p.eat_keyword(sym::pure) {
406 try_set_option(p, args, sym::pure, ast::InlineAsmOptions::PURE);
407 } else if !is_global_asm && p.eat_keyword(sym::nomem) {
408 try_set_option(p, args, sym::nomem, ast::InlineAsmOptions::NOMEM);
409 } else if !is_global_asm && p.eat_keyword(sym::readonly) {
410 try_set_option(p, args, sym::readonly, ast::InlineAsmOptions::READONLY);
411 } else if !is_global_asm && p.eat_keyword(sym::preserves_flags) {
412 try_set_option(p, args, sym::preserves_flags, ast::InlineAsmOptions::PRESERVES_FLAGS);
413 } else if !is_global_asm && p.eat_keyword(sym::noreturn) {
414 try_set_option(p, args, sym::noreturn, ast::InlineAsmOptions::NORETURN);
415 } else if !is_global_asm && p.eat_keyword(sym::nostack) {
416 try_set_option(p, args, sym::nostack, ast::InlineAsmOptions::NOSTACK);
417 } else if !is_global_asm && p.eat_keyword(sym::may_unwind) {
418 try_set_option(p, args, kw::Raw, ast::InlineAsmOptions::MAY_UNWIND);
419 } else if p.eat_keyword(sym::att_syntax) {
420 try_set_option(p, args, sym::att_syntax, ast::InlineAsmOptions::ATT_SYNTAX);
421 } else if p.eat_keyword(kw::Raw) {
422 try_set_option(p, args, kw::Raw, ast::InlineAsmOptions::RAW);
424 return p.unexpected();
427 // Allow trailing commas
428 if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
431 p.expect(&token::Comma)?;
434 let new_span = span_start.to(p.prev_token.span);
435 args.options_spans.push(new_span);
440 fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a, ()> {
441 let span_start = p.prev_token.span;
443 p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
445 if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
446 let err = p.sess.span_diagnostic.struct_span_err(
448 "at least one abi must be provided as an argument to `clobber_abi`",
453 let mut new_abis = Vec::new();
455 match p.parse_str_lit() {
457 new_abis.push((str_lit.symbol_unescaped, str_lit.span));
460 // If the non-string literal is a closing paren then it's the end of the list and is fine
461 if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
464 let span = opt_lit.map_or(p.token.span, |lit| lit.span);
466 p.sess.span_diagnostic.struct_span_err(span, "expected string literal");
467 err.span_label(span, "not a string literal");
472 // Allow trailing commas
473 if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
476 p.expect(&token::Comma)?;
479 let full_span = span_start.to(p.prev_token.span);
481 if !args.options_spans.is_empty() {
485 .struct_span_err(full_span, "clobber_abi is not allowed after options");
486 err.span_labels(args.options_spans.clone(), "options");
490 match &new_abis[..] {
491 // should have errored above during parsing
492 [] => unreachable!(),
493 [(abi, _span)] => args.clobber_abis.push((*abi, full_span)),
495 for (abi, span) in abis {
496 args.clobber_abis.push((*abi, *span));
506 explicit_reg: &mut bool,
507 ) -> PResult<'a, ast::InlineAsmRegOrRegClass> {
508 p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
509 let result = match p.token.uninterpolate().kind {
510 token::Ident(name, false) => ast::InlineAsmRegOrRegClass::RegClass(name),
511 token::Literal(token::Lit { kind: token::LitKind::Str, symbol, suffix: _ }) => {
512 *explicit_reg = true;
513 ast::InlineAsmRegOrRegClass::Reg(symbol)
517 p.struct_span_err(p.token.span, "expected register class or explicit register")
522 p.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
526 fn expand_preparsed_asm(ecx: &mut ExtCtxt<'_>, args: AsmArgs) -> Option<ast::InlineAsm> {
527 let mut template = vec![];
528 // Register operands are implicitly used since they are not allowed to be
529 // referenced in the template string.
530 let mut used = vec![false; args.operands.len()];
531 for pos in &args.reg_args {
534 let named_pos: FxHashMap<usize, Symbol> =
535 args.named_args.iter().map(|(&sym, &idx)| (idx, sym)).collect();
536 let mut line_spans = Vec::with_capacity(args.templates.len());
539 let mut template_strs = Vec::with_capacity(args.templates.len());
541 for (i, template_expr) in args.templates.into_iter().enumerate() {
543 template.push(ast::InlineAsmTemplatePiece::String("\n".to_string()));
546 let msg = "asm template must be a string literal";
547 let template_sp = template_expr.span;
548 let (template_str, template_style, template_span) =
549 match expr_to_spanned_string(ecx, template_expr, msg) {
550 Ok(template_part) => template_part,
552 if let Some((mut err, _)) = err {
559 let str_style = match template_style {
560 ast::StrStyle::Cooked => None,
561 ast::StrStyle::Raw(raw) => Some(raw as usize),
564 let template_snippet = ecx.source_map().span_to_snippet(template_sp).ok();
567 template_snippet.as_deref().map(Symbol::intern),
570 let template_str = template_str.as_str();
572 if let Some(InlineAsmArch::X86 | InlineAsmArch::X86_64) = ecx.sess.asm_arch {
573 let find_span = |needle: &str| -> Span {
574 if let Some(snippet) = &template_snippet {
575 if let Some(pos) = snippet.find(needle) {
578 .find(|c| matches!(c, '\n' | ';' | '\\' | '"'))
579 .unwrap_or(snippet[pos..].len() - 1);
580 let inner = InnerSpan::new(pos, end);
581 return template_sp.from_inner(inner);
587 if template_str.contains(".intel_syntax") {
588 ecx.parse_sess().buffer_lint(
589 lint::builtin::BAD_ASM_STYLE,
590 find_span(".intel_syntax"),
591 ecx.current_expansion.lint_node_id,
592 "avoid using `.intel_syntax`, Intel syntax is the default",
595 if template_str.contains(".att_syntax") {
596 ecx.parse_sess().buffer_lint(
597 lint::builtin::BAD_ASM_STYLE,
598 find_span(".att_syntax"),
599 ecx.current_expansion.lint_node_id,
600 "avoid using `.att_syntax`, prefer using `options(att_syntax)` instead",
605 // Don't treat raw asm as a format string.
606 if args.options.contains(ast::InlineAsmOptions::RAW) {
607 template.push(ast::InlineAsmTemplatePiece::String(template_str.to_string()));
608 let template_num_lines = 1 + template_str.matches('\n').count();
609 line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
613 let mut parser = parse::Parser::new(
618 parse::ParseMode::InlineAsm,
620 parser.curarg = curarg;
622 let mut unverified_pieces = Vec::new();
623 while let Some(piece) = parser.next() {
624 if !parser.errors.is_empty() {
627 unverified_pieces.push(piece);
631 if !parser.errors.is_empty() {
632 let err = parser.errors.remove(0);
633 let err_sp = template_span.from_inner(InnerSpan::new(err.span.start, err.span.end));
634 let msg = &format!("invalid asm template string: {}", err.description);
635 let mut e = ecx.struct_span_err(err_sp, msg);
636 e.span_label(err_sp, err.label + " in asm template string");
637 if let Some(note) = err.note {
640 if let Some((label, span)) = err.secondary_label {
641 let err_sp = template_span.from_inner(InnerSpan::new(span.start, span.end));
642 e.span_label(err_sp, label);
648 curarg = parser.curarg;
650 let mut arg_spans = parser
653 .map(|span| template_span.from_inner(InnerSpan::new(span.start, span.end)));
654 for piece in unverified_pieces {
656 parse::Piece::String(s) => {
657 template.push(ast::InlineAsmTemplatePiece::String(s.to_string()))
659 parse::Piece::NextArgument(arg) => {
660 let span = arg_spans.next().unwrap_or(template_sp);
662 let operand_idx = match arg.position {
663 parse::ArgumentIs(idx) | parse::ArgumentImplicitlyIs(idx) => {
664 if idx >= args.operands.len()
665 || named_pos.contains_key(&idx)
666 || args.reg_args.contains(&idx)
668 let msg = format!("invalid reference to argument at index {}", idx);
669 let mut err = ecx.struct_span_err(span, &msg);
670 err.span_label(span, "from here");
672 let positional_args = args.operands.len()
673 - args.named_args.len()
674 - args.reg_args.len();
675 let positional = if positional_args != args.operands.len() {
680 let msg = match positional_args {
681 0 => format!("no {}arguments were given", positional),
682 1 => format!("there is 1 {}argument", positional),
683 x => format!("there are {} {}arguments", x, positional),
687 if named_pos.contains_key(&idx) {
688 err.span_label(args.operands[idx].1, "named argument");
690 args.operands[idx].1,
691 "named arguments cannot be referenced by position",
693 } else if args.reg_args.contains(&idx) {
695 args.operands[idx].1,
696 "explicit register argument",
699 args.operands[idx].1,
700 "explicit register arguments cannot be used in the asm template",
709 parse::ArgumentNamed(name) => {
710 match args.named_args.get(&Symbol::intern(name)) {
711 Some(&idx) => Some(idx),
713 let msg = format!("there is no argument named `{}`", name);
714 let span = arg.position_span;
717 .from_inner(InnerSpan::new(span.start, span.end)),
727 let mut chars = arg.format.ty.chars();
728 let mut modifier = chars.next();
729 if chars.next().is_some() {
733 .map(|sp| template_sp.from_inner(InnerSpan::new(sp.start, sp.end)))
734 .unwrap_or(template_sp);
737 "asm template modifier must be a single character",
743 if let Some(operand_idx) = operand_idx {
744 used[operand_idx] = true;
745 template.push(ast::InlineAsmTemplatePiece::Placeholder {
755 if parser.line_spans.is_empty() {
756 let template_num_lines = 1 + template_str.matches('\n').count();
757 line_spans.extend(std::iter::repeat(template_sp).take(template_num_lines));
763 .map(|span| template_span.from_inner(InnerSpan::new(span.start, span.end))),
768 let mut unused_operands = vec![];
769 let mut help_str = String::new();
770 for (idx, used) in used.into_iter().enumerate() {
772 let msg = if let Some(sym) = named_pos.get(&idx) {
773 help_str.push_str(&format!(" {{{}}}", sym));
774 "named argument never used"
776 help_str.push_str(&format!(" {{{}}}", idx));
777 "argument never used"
779 unused_operands.push((args.operands[idx].1, msg));
782 match unused_operands.len() {
785 let (sp, msg) = unused_operands.into_iter().next().unwrap();
786 let mut err = ecx.struct_span_err(sp, msg);
787 err.span_label(sp, msg);
789 "if this argument is intentionally unused, \
790 consider using it in an asm comment: `\"/*{} */\"`",
796 let mut err = ecx.struct_span_err(
797 unused_operands.iter().map(|&(sp, _)| sp).collect::<Vec<Span>>(),
798 "multiple unused asm arguments",
800 for (sp, msg) in unused_operands {
801 err.span_label(sp, msg);
804 "if these arguments are intentionally unused, \
805 consider using them in an asm comment: `\"/*{} */\"`",
812 Some(ast::InlineAsm {
814 template_strs: template_strs.into_boxed_slice(),
815 operands: args.operands,
816 clobber_abis: args.clobber_abis,
817 options: args.options,
822 pub(super) fn expand_asm<'cx>(
823 ecx: &'cx mut ExtCtxt<'_>,
826 ) -> Box<dyn base::MacResult + 'cx> {
827 match parse_args(ecx, sp, tts, false) {
829 let expr = if let Some(inline_asm) = expand_preparsed_asm(ecx, args) {
831 id: ast::DUMMY_NODE_ID,
832 kind: ast::ExprKind::InlineAsm(P(inline_asm)),
834 attrs: ast::AttrVec::new(),
838 DummyResult::raw_expr(sp, true)
849 pub(super) fn expand_global_asm<'cx>(
850 ecx: &'cx mut ExtCtxt<'_>,
853 ) -> Box<dyn base::MacResult + 'cx> {
854 match parse_args(ecx, sp, tts, true) {
856 if let Some(inline_asm) = expand_preparsed_asm(ecx, args) {
857 MacEager::items(smallvec![P(ast::Item {
858 ident: Ident::empty(),
859 attrs: ast::AttrVec::new(),
860 id: ast::DUMMY_NODE_ID,
861 kind: ast::ItemKind::GlobalAsm(Box::new(inline_asm)),
862 vis: ast::Visibility {
863 span: sp.shrink_to_lo(),
864 kind: ast::VisibilityKind::Inherited,
867 span: ecx.with_def_site_ctxt(sp),