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 span_err!(cx, sp, E0660, "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 span_err!(cx, span, E0661,
146 "output operand constraint lacks '=' or '+'");
151 let is_rw = output.is_some();
152 let is_indirect = constraint_str.contains("*");
153 outputs.push(ast::InlineAsmOutput {
154 constraint: output.unwrap_or(constraint),
162 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
164 if !inputs.is_empty() {
165 p.eat(&token::Comma);
168 let (constraint, _str_style) = panictry!(p.parse_str());
170 if constraint.as_str().starts_with("=") {
171 span_err!(cx, p.prev_span, E0662,
172 "input operand constraint contains '='");
173 } else if constraint.as_str().starts_with("+") {
174 span_err!(cx, p.prev_span, E0663,
175 "input operand constraint contains '+'");
178 panictry!(p.expect(&token::OpenDelim(token::Paren)));
179 let input = panictry!(p.parse_expr());
180 panictry!(p.expect(&token::CloseDelim(token::Paren)));
182 inputs.push((constraint, input));
186 while p.token != token::Eof && p.token != token::Colon && p.token != token::ModSep {
188 if !clobs.is_empty() {
189 p.eat(&token::Comma);
192 let (s, _str_style) = panictry!(p.parse_str());
194 if OPTIONS.iter().any(|&opt| s == opt) {
195 cx.span_warn(p.prev_span, "expected a clobber, found an option");
196 } else if s.as_str().starts_with("{") || s.as_str().ends_with("}") {
197 span_err!(cx, p.prev_span, E0664,
198 "clobber should not be surrounded by braces");
205 let (option, _str_style) = panictry!(p.parse_str());
207 if option == "volatile" {
208 // Indicates that the inline assembly has side effects
209 // and must not be optimized out along with its outputs.
211 } else if option == "alignstack" {
213 } else if option == "intel" {
214 dialect = AsmDialect::Intel;
216 cx.span_warn(p.prev_span, "unrecognized option");
219 if p.token == token::Comma {
220 p.eat(&token::Comma);
227 // MOD_SEP is a double colon '::' without space in between.
228 // When encountered, the state must be advanced twice.
229 match (&p.token, state.next(), state.next().next()) {
230 (&token::Colon, StateNone, _) |
231 (&token::ModSep, _, StateNone) => {
235 (&token::Colon, st, _) |
236 (&token::ModSep, _, st) => {
240 (&token::Eof, ..) => break 'statement,
246 // If there are no outputs, the inline assembly is executed just for its side effects,
247 // so ensure that it is volatile
248 if outputs.is_empty() {
252 MacEager::expr(P(ast::Expr {
253 id: ast::DUMMY_NODE_ID,
254 node: ast::ExprKind::InlineAsm(P(ast::InlineAsm {
256 asm_str_style: asm_str_style.unwrap(),
263 ctxt: cx.backtrace(),
266 attrs: ast::ThinVec::new(),