src/libsyntax_ext/asm.rs

   1 // Inline assembly support.
   2 //
   3 use State::*;
   4
   5 use errors::{DiagnosticBuilder, PResult};
   6 use rustc_data_structures::thin_vec::ThinVec;
   7 use rustc_parse::parser::Parser;
   8 use syntax_expand::base::*;
   9 use syntax_pos::Span;
  10 use syntax::{span_err, struct_span_err};
  11 use syntax::ast::{self, AsmDialect};
  12 use syntax::ptr::P;
  13 use syntax::symbol::{kw, sym, Symbol};
  14 use syntax::token::{self, Token};
  15 use syntax::tokenstream::{self, TokenStream};
  16
  17 use rustc_error_codes::*;
  18
  19 enum State {
  20     Asm,
  21     Outputs,
  22     Inputs,
  23     Clobbers,
  24     Options,
  25     StateNone,
  26 }
  27
  28 impl State {
  29     fn next(&self) -> State {
  30         match *self {
  31             Asm => Outputs,
  32             Outputs => Inputs,
  33             Inputs => Clobbers,
  34             Clobbers => Options,
  35             Options => StateNone,
  36             StateNone => StateNone,
  37         }
  38     }
  39 }
  40
  41 const OPTIONS: &[Symbol] = &[sym::volatile, sym::alignstack, sym::intel];
  42
  43 pub fn expand_asm<'cx>(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: ThinVec::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.trees()
  90         .position(|tt| {
  91             match tt {
  92                 tokenstream::TokenTree::Token(Token { kind: token::Colon, .. }) |
  93                 tokenstream::TokenTree::Token(Token { kind: token::ModSep, .. }) => true,
  94                 _ => false,
  95             }
  96         })
  97         .unwrap_or(tts.len());
  98     let mut p = cx.new_parser_from_tts(tts.trees().skip(first_colon).collect());
  99     let mut asm = kw::Invalid;
 100     let mut asm_str_style = None;
 101     let mut outputs = Vec::new();
 102     let mut inputs = Vec::new();
 103     let mut clobs = Vec::new();
 104     let mut volatile = false;
 105     let mut alignstack = false;
 106     let mut dialect = AsmDialect::Att;
 107
 108     let mut state = Asm;
 109
 110     'statement: loop {
 111         match state {
 112             Asm => {
 113                 if asm_str_style.is_some() {
 114                     // If we already have a string with instructions,
 115                     // ending up in Asm state again is an error.
 116                     return Err(struct_span_err!(
 117                         cx.parse_sess.span_diagnostic,
 118                         sp,
 119                         E0660,
 120                         "malformed inline assembly"
 121                     ));
 122                 }
 123                 // Nested parser, stop before the first colon (see above).
 124                 let mut p2 =
 125                     cx.new_parser_from_tts(tts.trees().take(first_colon).collect());
 126
 127                 if p2.token == token::Eof {
 128                     let mut err =
 129                         cx.struct_span_err(sp, "macro requires a string literal as an argument");
 130                     err.span_label(sp, "string literal required");
 131                     return Err(err);
 132                 }
 133
 134                 let expr = p2.parse_expr()?;
 135                 let (s, style) =
 136                     match expr_to_string(cx, expr, "inline assembly must be a string literal") {
 137                         Some((s, st)) => (s, st),
 138                         None => return Ok(None),
 139                     };
 140
 141                 // This is most likely malformed.
 142                 if p2.token != token::Eof {
 143                     let mut extra_tts = p2.parse_all_token_trees()?;
 144                     extra_tts.extend(tts.trees().skip(first_colon));
 145                     p = cx.new_parser_from_tts(extra_tts.into_iter().collect());
 146                 }
 147
 148                 asm = s;
 149                 asm_str_style = Some(style);
 150             }
 151             Outputs => {
 152                 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
 153                     if !outputs.is_empty() {
 154                         p.eat(&token::Comma);
 155                     }
 156
 157                     let constraint = parse_asm_str(&mut p)?;
 158
 159                     let span = p.prev_span;
 160
 161                     p.expect(&token::OpenDelim(token::Paren))?;
 162                     let expr = p.parse_expr()?;
 163                     p.expect(&token::CloseDelim(token::Paren))?;
 164
 165                     // Expands a read+write operand into two operands.
 166                     //
 167                     // Use '+' modifier when you want the same expression
 168                     // to be both an input and an output at the same time.
 169                     // It's the opposite of '=&' which means that the memory
 170                     // cannot be shared with any other operand (usually when
 171                     // a register is clobbered early.)
 172                     let constraint_str = constraint.as_str();
 173                     let mut ch = constraint_str.chars();
 174                     let output = match ch.next() {
 175                         Some('=') => None,
 176                         Some('+') => {
 177                             Some(Symbol::intern(&format!("={}", ch.as_str())))
 178                         }
 179                         _ => {
 180                             span_err!(cx, span, E0661,
 181                                                     "output operand constraint lacks '=' or '+'");
 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,
 206                                                 "input operand constraint contains '='");
 207                     } else if constraint.as_str().starts_with("+") {
 208                         span_err!(cx, p.prev_span, E0663,
 209                                                 "input operand constraint contains '+'");
 210                     }
 211
 212                     p.expect(&token::OpenDelim(token::Paren))?;
 213                     let input = p.parse_expr()?;
 214                     p.expect(&token::CloseDelim(token::Paren))?;
 215
 216                     inputs.push((constraint, input));
 217                 }
 218             }
 219             Clobbers => {
 220                 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
 221                     if !clobs.is_empty() {
 222                         p.eat(&token::Comma);
 223                     }
 224
 225                     let s = parse_asm_str(&mut p)?;
 226
 227                     if OPTIONS.iter().any(|&opt| s == opt) {
 228                         cx.span_warn(p.prev_span, "expected a clobber, found an option");
 229                     } else if s.as_str().starts_with("{") || s.as_str().ends_with("}") {
 230                         span_err!(cx, p.prev_span, E0664,
 231                                                 "clobber should not be surrounded by braces");
 232                     }
 233
 234                     clobs.push(s);
 235                 }
 236             }
 237             Options => {
 238                 let option = parse_asm_str(&mut p)?;
 239
 240                 if option == sym::volatile {
 241                     // Indicates that the inline assembly has side effects
 242                     // and must not be optimized out along with its outputs.
 243                     volatile = true;
 244                 } else if option == sym::alignstack {
 245                     alignstack = true;
 246                 } else if option == sym::intel {
 247                     dialect = AsmDialect::Intel;
 248                 } else {
 249                     cx.span_warn(p.prev_span, "unrecognized option");
 250                 }
 251
 252                 if p.token == token::Comma {
 253                     p.eat(&token::Comma);
 254                 }
 255             }
 256             StateNone => (),
 257         }
 258
 259         loop {
 260             // MOD_SEP is a double colon '::' without space in between.
 261             // When encountered, the state must be advanced twice.
 262             match (&p.token.kind, state.next(), state.next().next()) {
 263                 (&token::Colon, StateNone, _) |
 264                 (&token::ModSep, _, StateNone) => {
 265                     p.bump();
 266                     break 'statement;
 267                 }
 268                 (&token::Colon, st, _) |
 269                 (&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 }