src/librustc_builtin_macros/asm.rs

   1 // Inline assembly support.
   2 //
   3 use State::*;
   4
   5 use errors::{DiagnosticBuilder, PResult};
   6 use rustc_expand::base::*;
   7 use rustc_parse::parser::Parser;
   8 use rustc_span::symbol::{kw, sym, Symbol};
   9 use rustc_span::Span;
  10 use syntax::ast::{self, AsmDialect};
  11 use syntax::ptr::P;
  12 use syntax::token::{self, Token};
  13 use syntax::tokenstream::{self, TokenStream};
  14 use syntax::{span_err, struct_span_err};
  15
  16 use rustc_error_codes::*;
  17
  18 enum State {
  19     Asm,
  20     Outputs,
  21     Inputs,
  22     Clobbers,
  23     Options,
  24     StateNone,
  25 }
  26
  27 impl State {
  28     fn next(&self) -> State {
  29         match *self {
  30             Asm => Outputs,
  31             Outputs => Inputs,
  32             Inputs => Clobbers,
  33             Clobbers => Options,
  34             Options => StateNone,
  35             StateNone => StateNone,
  36         }
  37     }
  38 }
  39
  40 const OPTIONS: &[Symbol] = &[sym::volatile, sym::alignstack, sym::intel];
  41
  42 pub fn expand_asm<'cx>(
  43     cx: &'cx mut ExtCtxt<'_>,
  44     sp: Span,
  45     tts: TokenStream,
  46 ) -> Box<dyn MacResult + 'cx> {
  47     let mut inline_asm = match parse_inline_asm(cx, sp, tts) {
  48         Ok(Some(inline_asm)) => inline_asm,
  49         Ok(None) => return DummyResult::any(sp),
  50         Err(mut err) => {
  51             err.emit();
  52             return DummyResult::any(sp);
  53         }
  54     };
  55
  56     // If there are no outputs, the inline assembly is executed just for its side effects,
  57     // so ensure that it is volatile
  58     if inline_asm.outputs.is_empty() {
  59         inline_asm.volatile = true;
  60     }
  61
  62     MacEager::expr(P(ast::Expr {
  63         id: ast::DUMMY_NODE_ID,
  64         kind: ast::ExprKind::InlineAsm(P(inline_asm)),
  65         span: cx.with_def_site_ctxt(sp),
  66         attrs: ast::AttrVec::new(),
  67     }))
  68 }
  69
  70 fn parse_asm_str<'a>(p: &mut Parser<'a>) -> PResult<'a, Symbol> {
  71     match p.parse_str_lit() {
  72         Ok(str_lit) => Ok(str_lit.symbol_unescaped),
  73         Err(opt_lit) => {
  74             let span = opt_lit.map_or(p.token.span, |lit| lit.span);
  75             let mut err = p.sess.span_diagnostic.struct_span_err(span, "expected string literal");
  76             err.span_label(span, "not a string literal");
  77             Err(err)
  78         }
  79     }
  80 }
  81
  82 fn parse_inline_asm<'a>(
  83     cx: &mut ExtCtxt<'a>,
  84     sp: Span,
  85     tts: TokenStream,
  86 ) -> Result<Option<ast::InlineAsm>, DiagnosticBuilder<'a>> {
  87     // Split the tts before the first colon, to avoid `asm!("x": y)`  being
  88     // parsed as `asm!(z)` with `z = "x": y` which is type ascription.
  89     let first_colon = tts
  90         .trees()
  91         .position(|tt| match tt {
  92             tokenstream::TokenTree::Token(Token { kind: token::Colon, .. })
  93             | tokenstream::TokenTree::Token(Token { kind: token::ModSep, .. }) => true,
  94             _ => false,
  95         })
  96         .unwrap_or(tts.len());
  97     let mut p = cx.new_parser_from_tts(tts.trees().skip(first_colon).collect());
  98     let mut asm = kw::Invalid;
  99     let mut asm_str_style = None;
 100     let mut outputs = Vec::new();
 101     let mut inputs = Vec::new();
 102     let mut clobs = Vec::new();
 103     let mut volatile = false;
 104     let mut alignstack = false;
 105     let mut dialect = AsmDialect::Att;
 106
 107     let mut state = Asm;
 108
 109     'statement: loop {
 110         match state {
 111             Asm => {
 112                 if asm_str_style.is_some() {
 113                     // If we already have a string with instructions,
 114                     // ending up in Asm state again is an error.
 115                     return Err(struct_span_err!(
 116                         cx.parse_sess.span_diagnostic,
 117                         sp,
 118                         E0660,
 119                         "malformed inline assembly"
 120                     ));
 121                 }
 122                 // Nested parser, stop before the first colon (see above).
 123                 let mut p2 = cx.new_parser_from_tts(tts.trees().take(first_colon).collect());
 124
 125                 if p2.token == token::Eof {
 126                     let mut err =
 127                         cx.struct_span_err(sp, "macro requires a string literal as an argument");
 128                     err.span_label(sp, "string literal required");
 129                     return Err(err);
 130                 }
 131
 132                 let expr = p2.parse_expr()?;
 133                 let (s, style) =
 134                     match expr_to_string(cx, expr, "inline assembly must be a string literal") {
 135                         Some((s, st)) => (s, st),
 136                         None => return Ok(None),
 137                     };
 138
 139                 // This is most likely malformed.
 140                 if p2.token != token::Eof {
 141                     let mut extra_tts = p2.parse_all_token_trees()?;
 142                     extra_tts.extend(tts.trees().skip(first_colon));
 143                     p = cx.new_parser_from_tts(extra_tts.into_iter().collect());
 144                 }
 145
 146                 asm = s;
 147                 asm_str_style = Some(style);
 148             }
 149             Outputs => {
 150                 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
 151                     if !outputs.is_empty() {
 152                         p.eat(&token::Comma);
 153                     }
 154
 155                     let constraint = parse_asm_str(&mut p)?;
 156
 157                     let span = p.prev_span;
 158
 159                     p.expect(&token::OpenDelim(token::Paren))?;
 160                     let expr = p.parse_expr()?;
 161                     p.expect(&token::CloseDelim(token::Paren))?;
 162
 163                     // Expands a read+write operand into two operands.
 164                     //
 165                     // Use '+' modifier when you want the same expression
 166                     // to be both an input and an output at the same time.
 167                     // It's the opposite of '=&' which means that the memory
 168                     // cannot be shared with any other operand (usually when
 169                     // a register is clobbered early.)
 170                     let constraint_str = constraint.as_str();
 171                     let mut ch = constraint_str.chars();
 172                     let output = match ch.next() {
 173                         Some('=') => None,
 174                         Some('+') => Some(Symbol::intern(&format!("={}", ch.as_str()))),
 175                         _ => {
 176                             span_err!(
 177                                 cx,
 178                                 span,
 179                                 E0661,
 180                                 "output operand constraint lacks '=' or '+'"
 181                             );
 182                             None
 183                         }
 184                     };
 185
 186                     let is_rw = output.is_some();
 187                     let is_indirect = constraint_str.contains("*");
 188                     outputs.push(ast::InlineAsmOutput {
 189                         constraint: output.unwrap_or(constraint),
 190                         expr,
 191                         is_rw,
 192                         is_indirect,
 193                     });
 194                 }
 195             }
 196             Inputs => {
 197                 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
 198                     if !inputs.is_empty() {
 199                         p.eat(&token::Comma);
 200                     }
 201
 202                     let constraint = parse_asm_str(&mut p)?;
 203
 204                     if constraint.as_str().starts_with("=") {
 205                         span_err!(cx, p.prev_span, E0662, "input operand constraint contains '='");
 206                     } else if constraint.as_str().starts_with("+") {
 207                         span_err!(cx, p.prev_span, E0663, "input operand constraint contains '+'");
 208                     }
 209
 210                     p.expect(&token::OpenDelim(token::Paren))?;
 211                     let input = p.parse_expr()?;
 212                     p.expect(&token::CloseDelim(token::Paren))?;
 213
 214                     inputs.push((constraint, input));
 215                 }
 216             }
 217             Clobbers => {
 218                 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
 219                     if !clobs.is_empty() {
 220                         p.eat(&token::Comma);
 221                     }
 222
 223                     let s = parse_asm_str(&mut p)?;
 224
 225                     if OPTIONS.iter().any(|&opt| s == opt) {
 226                         cx.span_warn(p.prev_span, "expected a clobber, found an option");
 227                     } else if s.as_str().starts_with("{") || s.as_str().ends_with("}") {
 228                         span_err!(
 229                             cx,
 230                             p.prev_span,
 231                             E0664,
 232                             "clobber should not be surrounded by braces"
 233                         );
 234                     }
 235
 236                     clobs.push(s);
 237                 }
 238             }
 239             Options => {
 240                 let option = parse_asm_str(&mut p)?;
 241
 242                 if option == sym::volatile {
 243                     // Indicates that the inline assembly has side effects
 244                     // and must not be optimized out along with its outputs.
 245                     volatile = true;
 246                 } else if option == sym::alignstack {
 247                     alignstack = true;
 248                 } else if option == sym::intel {
 249                     dialect = AsmDialect::Intel;
 250                 } else {
 251                     cx.span_warn(p.prev_span, "unrecognized option");
 252                 }
 253
 254                 if p.token == token::Comma {
 255                     p.eat(&token::Comma);
 256                 }
 257             }
 258             StateNone => (),
 259         }
 260
 261         loop {
 262             // MOD_SEP is a double colon '::' without space in between.
 263             // When encountered, the state must be advanced twice.
 264             match (&p.token.kind, state.next(), state.next().next()) {
 265                 (&token::Colon, StateNone, _) | (&token::ModSep, _, StateNone) => {
 266                     p.bump();
 267                     break 'statement;
 268                 }
 269                 (&token::Colon, st, _) | (&token::ModSep, _, st) => {
 270                     p.bump();
 271                     state = st;
 272                 }
 273                 (&token::Eof, ..) => break 'statement,
 274                 _ => break,
 275             }
 276         }
 277     }
 278
 279     Ok(Some(ast::InlineAsm {
 280         asm,
 281         asm_str_style: asm_str_style.unwrap(),
 282         outputs,
 283         inputs,
 284         clobbers: clobs,
 285         volatile,
 286         alignstack,
 287         dialect,
 288     }))
 289 }