1 // Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 // Inline assembly support.
16 use syntax::ext::base;
17 use syntax::ext::base::*;
18 use syntax::feature_gate;
19 use syntax::parse::{self, token};
21 use syntax::symbol::Symbol;
22 use syntax::ast::AsmDialect;
24 use syntax::tokenstream;
36 fn next(&self) -> State {
43 StateNone => StateNone,
48 const OPTIONS: &'static [&'static str] = &["volatile", "alignstack", "intel"];
50 pub fn expand_asm<'cx>(cx: &'cx mut ExtCtxt,
52 tts: &[tokenstream::TokenTree])
53 -> Box<base::MacResult + 'cx> {
54 if !cx.ecfg.enable_asm() {
55 feature_gate::emit_feature_err(&cx.parse_sess,
58 feature_gate::GateIssue::Language,
59 feature_gate::EXPLAIN_ASM);
60 return DummyResult::expr(sp);
63 // Split the tts before the first colon, to avoid `asm!("x": y)` being
64 // parsed as `asm!(z)` with `z = "x": y` which is type ascription.
65 let first_colon = tts.iter()
68 tokenstream::TokenTree::Token(_, token::Colon) |
69 tokenstream::TokenTree::Token(_, token::ModSep) => true,
73 .unwrap_or(tts.len());
74 let mut p = cx.new_parser_from_tts(&tts[first_colon..]);
75 let mut asm = Symbol::intern("");
76 let mut asm_str_style = None;
77 let mut outputs = Vec::new();
78 let mut inputs = Vec::new();
79 let mut clobs = Vec::new();
80 let mut volatile = false;
81 let mut alignstack = false;
82 let mut dialect = AsmDialect::Att;
89 if asm_str_style.is_some() {
90 // If we already have a string with instructions,
91 // ending up in Asm state again is an error.
92 cx.span_err(sp, "malformed inline assembly");
93 return DummyResult::expr(sp);
95 // Nested parser, stop before the first colon (see above).
96 let mut p2 = cx.new_parser_from_tts(&tts[..first_colon]);
97 let (s, style) = match expr_to_string(cx,
98 panictry!(p2.parse_expr()),
99 "inline assembly must be a string literal") {
100 Some((s, st)) => (s, st),
101 // let compilation continue
102 None => return DummyResult::expr(sp),
105 // This is most likely malformed.
106 if p2.token != token::Eof {
107 let mut extra_tts = panictry!(p2.parse_all_token_trees());
108 extra_tts.extend(tts[first_colon..].iter().cloned());
109 p = parse::stream_to_parser(cx.parse_sess, extra_tts.into_iter().collect());
113 asm_str_style = Some(style);
116 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
118 if !outputs.is_empty() {
119 p.eat(&token::Comma);
122 let (constraint, _str_style) = panictry!(p.parse_str());
124 let span = p.prev_span;
126 panictry!(p.expect(&token::OpenDelim(token::Paren)));
127 let out = panictry!(p.parse_expr());
128 panictry!(p.expect(&token::CloseDelim(token::Paren)));
130 // Expands a read+write operand into two operands.
132 // Use '+' modifier when you want the same expression
133 // to be both an input and an output at the same time.
134 // It's the opposite of '=&' which means that the memory
135 // cannot be shared with any other operand (usually when
136 // a register is clobbered early.)
137 let constraint_str = constraint.as_str();
138 let mut ch = constraint_str.chars();
139 let output = match ch.next() {
142 Some(Symbol::intern(&format!("={}", ch.as_str())))
145 cx.span_err(span, "output operand constraint lacks '=' or '+'");
150 let is_rw = output.is_some();
151 let is_indirect = constraint_str.contains("*");
152 outputs.push(ast::InlineAsmOutput {
153 constraint: output.unwrap_or(constraint),
161 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
163 if !inputs.is_empty() {
164 p.eat(&token::Comma);
167 let (constraint, _str_style) = panictry!(p.parse_str());
169 if constraint.as_str().starts_with("=") {
170 cx.span_err(p.prev_span, "input operand constraint contains '='");
171 } else if constraint.as_str().starts_with("+") {
172 cx.span_err(p.prev_span, "input operand constraint contains '+'");
175 panictry!(p.expect(&token::OpenDelim(token::Paren)));
176 let input = panictry!(p.parse_expr());
177 panictry!(p.expect(&token::CloseDelim(token::Paren)));
179 inputs.push((constraint, input));
183 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
185 if !clobs.is_empty() {
186 p.eat(&token::Comma);
189 let (s, _str_style) = panictry!(p.parse_str());
191 if OPTIONS.iter().any(|&opt| s == opt) {
192 cx.span_warn(p.prev_span, "expected a clobber, found an option");
193 } else if s.as_str().starts_with("{") || s.as_str().ends_with("}") {
194 cx.span_err(p.prev_span, "clobber should not be surrounded by braces");
201 let (option, _str_style) = panictry!(p.parse_str());
203 if option == "volatile" {
204 // Indicates that the inline assembly has side effects
205 // and must not be optimized out along with its outputs.
207 } else if option == "alignstack" {
209 } else if option == "intel" {
210 dialect = AsmDialect::Intel;
212 cx.span_warn(p.prev_span, "unrecognized option");
215 if p.token == token::Comma {
216 p.eat(&token::Comma);
223 // MOD_SEP is a double colon '::' without space in between.
224 // When encountered, the state must be advanced twice.
225 match (&p.token, state.next(), state.next().next()) {
226 (&token::Colon, StateNone, _) |
227 (&token::ModSep, _, StateNone) => {
231 (&token::Colon, st, _) |
232 (&token::ModSep, _, st) => {
236 (&token::Eof, ..) => break 'statement,
242 // If there are no outputs, the inline assembly is executed just for its side effects,
243 // so ensure that it is volatile
244 if outputs.is_empty() {
248 MacEager::expr(P(ast::Expr {
249 id: ast::DUMMY_NODE_ID,
250 node: ast::ExprKind::InlineAsm(P(ast::InlineAsm {
252 asm_str_style: asm_str_style.unwrap(),
259 ctxt: cx.backtrace(),
262 attrs: ast::ThinVec::new(),