From ecccc0d649088720a8c4af86e1722b9a26ca31dc Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Sat, 9 Mar 2013 22:37:50 -0800 Subject: [PATCH 1/8] Parse inline assembly. --- src/etc/vim/syntax/rust.vim | 2 +- src/librustc/lib/llvm.rs | 5 +++++ src/librustc/middle/liveness.rs | 6 ++++-- src/librustc/middle/mem_categorization.rs | 2 +- src/librustc/middle/moves.rs | 3 ++- src/librustc/middle/trans/build.rs | 13 ++++++++++++- src/librustc/middle/trans/expr.rs | 8 ++++++++ src/librustc/middle/trans/type_use.rs | 2 +- src/librustc/middle/ty.rs | 1 + src/librustc/middle/typeck/check/mod.rs | 1 + src/librustc/middle/typeck/check/regionck.rs | 1 + src/libsyntax/ast.rs | 2 ++ src/libsyntax/fold.rs | 1 + src/libsyntax/parse/parser.rs | 10 +++++++++- src/libsyntax/parse/token.rs | 1 + src/libsyntax/print/pprust.rs | 8 ++++++++ src/libsyntax/visit.rs | 1 + src/rustllvm/RustWrapper.cpp | 12 ++++++++++++ src/rustllvm/rustllvm.def.in | 1 + 19 files changed, 72 insertions(+), 8 deletions(-) diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim index f811fbf585542..ccd1ddc243047 100644 --- a/src/etc/vim/syntax/rust.vim +++ b/src/etc/vim/syntax/rust.vim @@ -11,7 +11,7 @@ elseif exists("b:current_syntax") endif syn match rustAssert "\ ValueRef; } } diff --git a/src/librustc/middle/liveness.rs b/src/librustc/middle/liveness.rs index 0c17b371694c4..d300698da59d1 100644 --- a/src/librustc/middle/liveness.rs +++ b/src/librustc/middle/liveness.rs @@ -620,7 +620,8 @@ fn visit_expr(expr: @expr, &&self: @mut IrMaps, vt: vt<@mut IrMaps>) { expr_do_body(*) | expr_cast(*) | expr_unary(*) | expr_break(_) | expr_again(_) | expr_lit(_) | expr_ret(*) | expr_block(*) | expr_assign(*) | expr_swap(*) | expr_assign_op(*) | expr_mac(*) | - expr_struct(*) | expr_repeat(*) | expr_paren(*) => { + expr_struct(*) | expr_repeat(*) | expr_paren(*) | + expr_inline_asm(*) => { visit::visit_expr(expr, self, vt); } } @@ -1345,6 +1346,7 @@ pub impl Liveness { self.propagate_through_expr(e, succ) } + expr_inline_asm(*) | expr_lit(*) => { succ } @@ -1618,7 +1620,7 @@ fn check_expr(expr: @expr, &&self: @Liveness, vt: vt<@Liveness>) { expr_cast(*) | expr_unary(*) | expr_ret(*) | expr_break(*) | expr_again(*) | expr_lit(_) | expr_block(*) | expr_swap(*) | expr_mac(*) | expr_addr_of(*) | expr_struct(*) | expr_repeat(*) | - expr_paren(*) => { + expr_paren(*) | expr_inline_asm(*) => { visit::visit_expr(expr, self, vt); } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 9e0ecb5a21859..5881f95f29869 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -447,7 +447,7 @@ pub impl mem_categorization_ctxt { ast::expr_while(*) | ast::expr_block(*) | ast::expr_loop(*) | ast::expr_match(*) | ast::expr_lit(*) | ast::expr_break(*) | ast::expr_mac(*) | ast::expr_again(*) | ast::expr_struct(*) | - ast::expr_repeat(*) => { + ast::expr_repeat(*) | ast::expr_inline_asm(*) => { return self.cat_rvalue(expr, expr_ty); } } diff --git a/src/librustc/middle/moves.rs b/src/librustc/middle/moves.rs index 182697b290f76..734f4651f3bed 100644 --- a/src/librustc/middle/moves.rs +++ b/src/librustc/middle/moves.rs @@ -560,7 +560,8 @@ pub impl VisitContext { expr_break(*) | expr_again(*) | - expr_lit(*) => {} + expr_lit(*) | + expr_inline_asm(*) => {} expr_loop(ref blk, _) => { self.consume_block(blk, visitor); diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 45104480b4c9d..93459042d23c0 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -18,7 +18,7 @@ use syntax::codemap::span; use core::prelude::*; use core::cast; -use core::libc::{c_uint, c_int, c_ulonglong}; +use core::libc::{c_uint, c_int, c_ulonglong, c_char}; use core::libc; use core::option::Some; use core::ptr; @@ -872,6 +872,17 @@ pub fn add_comment(bcx: block, text: &str) { } } +pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char) -> ValueRef { + unsafe { + count_insn(cx, "inlineasm"); + + let llfty = T_fn(~[], T_void()); + let v = llvm::LLVMInlineAsm(llfty, asm, cons, False, False); + + Call(cx, v, ~[]) + } +} + pub fn Call(cx: block, Fn: ValueRef, Args: &[ValueRef]) -> ValueRef { if cx.unreachable { return _UndefReturn(cx, Fn); } unsafe { diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index e38b0be7bccba..9012d2587185c 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -691,6 +691,14 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, ast::expr_assign_op(op, dst, src) => { return trans_assign_op(bcx, expr, op, dst, src); } + ast::expr_inline_asm(asm, cons) => { + do str::as_c_str(*asm) |a| { + do str::as_c_str(*cons) |c| { + InlineAsmCall(bcx, a, c); + } + } + return bcx; + } _ => { bcx.tcx().sess.span_bug( expr.span, diff --git a/src/librustc/middle/trans/type_use.rs b/src/librustc/middle/trans/type_use.rs index 710bb5eb34601..9a0c330d2d106 100644 --- a/src/librustc/middle/trans/type_use.rs +++ b/src/librustc/middle/trans/type_use.rs @@ -353,7 +353,7 @@ pub fn mark_for_expr(cx: Context, e: @expr) { expr_match(*) | expr_block(_) | expr_if(*) | expr_while(*) | expr_break(_) | expr_again(_) | expr_unary(_, _) | expr_lit(_) | expr_mac(_) | expr_addr_of(_, _) | expr_ret(_) | expr_loop(_, _) | - expr_loop_body(_) | expr_do_body(_) => () + expr_loop_body(_) | expr_do_body(_) | expr_inline_asm(*) => () } } diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs index b4ef87491a8a3..6e21439fc3563 100644 --- a/src/librustc/middle/ty.rs +++ b/src/librustc/middle/ty.rs @@ -3076,6 +3076,7 @@ pub fn expr_kind(tcx: ctxt, ast::expr_block(*) | ast::expr_copy(*) | ast::expr_repeat(*) | + ast::expr_inline_asm(*) | ast::expr_lit(@codemap::spanned {node: lit_str(_), _}) | ast::expr_vstore(_, ast::expr_vstore_slice) | ast::expr_vstore(_, ast::expr_vstore_mut_slice) | diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index 6617fa3b27c91..bd36eb1cf5603 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -2303,6 +2303,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let region_lb = ty::re_scope(expr.id); instantiate_path(fcx, pth, tpt, expr.span, expr.id, region_lb); } + ast::expr_inline_asm(*) => { fcx.write_nil(id); } ast::expr_mac(_) => tcx.sess.bug(~"unexpanded macro"), ast::expr_break(_) => { fcx.write_bot(id); bot = true; } ast::expr_again(_) => { fcx.write_bot(id); bot = true; } diff --git a/src/librustc/middle/typeck/check/regionck.rs b/src/librustc/middle/typeck/check/regionck.rs index 55d027549e30c..1dd88e6408ba0 100644 --- a/src/librustc/middle/typeck/check/regionck.rs +++ b/src/librustc/middle/typeck/check/regionck.rs @@ -682,6 +682,7 @@ pub mod guarantor { // All of these expressions are rvalues and hence their // value is not guaranteed by a region pointer. + ast::expr_inline_asm(*) | ast::expr_mac(*) | ast::expr_lit(_) | ast::expr_unary(*) | diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 27dba9c2b5ebc..b7c30360613f9 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -600,6 +600,8 @@ pub enum expr_ { expr_again(Option), expr_ret(Option<@expr>), expr_log(log_level, @expr, @expr), + + expr_inline_asm(@~str /* asm */, @~str /* constraints */), expr_mac(mac), diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs index 427760c920f6d..15097f57b02e0 100644 --- a/src/libsyntax/fold.rs +++ b/src/libsyntax/fold.rs @@ -560,6 +560,7 @@ pub fn noop_fold_expr(e: &expr_, fld: @ast_fold) -> expr_ { fld.fold_expr(e) ) } + expr_inline_asm(*) => copy *e, expr_mac(ref mac) => expr_mac(fold_mac((*mac))), expr_struct(path, ref fields, maybe_expr) => { expr_struct( diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index 99c1c2cb1feec..6076ad0ce0ea3 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -27,7 +27,7 @@ use ast::{expr_field, expr_fn_block, expr_if, expr_index}; use ast::{expr_lit, expr_log, expr_loop, expr_loop_body, expr_mac}; use ast::{expr_method_call, expr_paren, expr_path, expr_repeat}; use ast::{expr_ret, expr_swap, expr_struct, expr_tup, expr_unary}; -use ast::{expr_vec, expr_vstore, expr_vstore_mut_box}; +use ast::{expr_vec, expr_vstore, expr_vstore_mut_box, expr_inline_asm}; use ast::{expr_vstore_fixed, expr_vstore_slice, expr_vstore_box}; use ast::{expr_vstore_mut_slice, expr_while, extern_fn, field, fn_decl}; use ast::{expr_vstore_uniq, TyClosure, TyBareFn, Onceness, Once, Many}; @@ -1184,6 +1184,14 @@ pub impl Parser { } } hi = self.span.hi; + } else if self.eat_keyword(&~"__asm__") { + self.expect(&token::LPAREN); + let asm = self.parse_str(); + self.expect(&token::COMMA); + let cons = self.parse_str(); + ex = expr_inline_asm(asm, cons); + hi = self.span.hi; + self.expect(&token::RPAREN); } else if self.eat_keyword(&~"log") { self.expect(&token::LPAREN); let lvl = self.parse_expr(); diff --git a/src/libsyntax/parse/token.rs b/src/libsyntax/parse/token.rs index 81aacbf173d5e..5cfe0bef9b860 100644 --- a/src/libsyntax/parse/token.rs +++ b/src/libsyntax/parse/token.rs @@ -488,6 +488,7 @@ pub fn temporary_keyword_table() -> HashMap<~str, ()> { pub fn strict_keyword_table() -> HashMap<~str, ()> { let words = HashMap(); let keys = ~[ + ~"__asm__", ~"as", ~"assert", ~"break", ~"const", ~"copy", diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 62f593f15c186..350ab0cf9b297 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1398,6 +1398,14 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) { } } } + ast::expr_inline_asm(a, c) => { + word(s.s, ~"__asm__"); + popen(s); + print_string(s, *a); + word_space(s, ~", "); + print_string(s, *c); + pclose(s); + } ast::expr_mac(ref m) => print_mac(s, (*m)), ast::expr_paren(e) => { popen(s); diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index f04894729bd0c..95ab603f58433 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -562,6 +562,7 @@ pub fn visit_expr(ex: @expr, e: E, v: vt) { } expr_mac(ref mac) => visit_mac((*mac), e, v), expr_paren(x) => (v.visit_expr)(x, e, v), + expr_inline_asm(*) => (), } (v.visit_expr_post)(ex, e, v); } diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index 3af936d34612b..f5efed5f3a01d 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -15,6 +15,7 @@ // //===----------------------------------------------------------------------=== +#include "llvm/InlineAsm.h" #include "llvm/LLVMContext.h" #include "llvm/Linker.h" #include "llvm/PassManager.h" @@ -539,3 +540,14 @@ extern "C" void LLVMSetDebug(int Enabled) { DebugFlag = Enabled; #endif } + +extern "C" LLVMValueRef LLVMInlineAsm(LLVMTypeRef Ty, + char *AsmString, + char *Constraints, + LLVMBool HasSideEffects, + LLVMBool IsAlignStack) { + return wrap(InlineAsm::get(unwrap(Ty), AsmString, + Constraints, HasSideEffects, + IsAlignStack)); +// IsAlignStack, InlineAsm::AD_Intel)); +} diff --git a/src/rustllvm/rustllvm.def.in b/src/rustllvm/rustllvm.def.in index ceedf4382963b..8b1c9d5ec7fbc 100644 --- a/src/rustllvm/rustllvm.def.in +++ b/src/rustllvm/rustllvm.def.in @@ -583,3 +583,4 @@ LLVMX86MMXTypeInContext LLVMConstNamedStruct LLVMStructCreateNamed LLVMStructSetBody +LLVMInlineAsm From fc78b93c413e53a43ec568e3ec1d74d35924093b Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Sun, 10 Mar 2013 00:38:29 -0800 Subject: [PATCH 2/8] Wrap llvm::InlineAsm::AsmDialect --- src/librustc/lib/llvm.rs | 15 +++++++++++---- src/librustc/middle/trans/build.rs | 7 ++++--- src/librustc/middle/trans/expr.rs | 2 +- src/rustllvm/RustWrapper.cpp | 6 +++--- 4 files changed, 19 insertions(+), 11 deletions(-) diff --git a/src/librustc/lib/llvm.rs b/src/librustc/lib/llvm.rs index 629ed75cfdac1..b0cc18a30a41d 100644 --- a/src/librustc/lib/llvm.rs +++ b/src/librustc/lib/llvm.rs @@ -188,6 +188,12 @@ pub enum Metadata { MD_tbaa_struct = 5 } +// Inline Asm Dialect +pub enum AsmDialect { + AD_ATT = 0, + AD_Intel = 1 +} + // Opaque pointer types pub enum Module_opaque {} pub type ModuleRef = *Module_opaque; @@ -217,9 +223,9 @@ pub enum SectionIterator_opaque {} pub type SectionIteratorRef = *SectionIterator_opaque; pub mod llvm { - use super::{AtomicBinOp, AtomicOrdering, BasicBlockRef, Bool, BuilderRef}; - use super::{ContextRef, MemoryBufferRef, ModuleRef, ObjectFileRef}; - use super::{Opcode, PassManagerRef, PassManagerBuilderRef}; + use super::{AsmDialect, AtomicBinOp, AtomicOrdering, BasicBlockRef}; + use super::{Bool, BuilderRef, ContextRef, MemoryBufferRef, ModuleRef}; + use super::{ObjectFileRef, Opcode, PassManagerRef, PassManagerBuilderRef}; use super::{SectionIteratorRef, TargetDataRef, TypeKind, TypeRef, UseRef}; use super::{ValueRef}; @@ -1437,7 +1443,8 @@ pub mod llvm { /** Prepares inline assembly. */ pub unsafe fn LLVMInlineAsm(Ty: TypeRef, AsmString: *c_char, Constraints: *c_char, SideEffects: Bool, - AlignStack: Bool) -> ValueRef; + AlignStack: Bool, Dialect: AsmDialect) + -> ValueRef; } } diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 93459042d23c0..ad86b6c924539 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -9,7 +9,7 @@ // except according to those terms. use lib::llvm::llvm; -use lib::llvm::{CallConv, TypeKind, AtomicBinOp, AtomicOrdering}; +use lib::llvm::{CallConv, TypeKind, AtomicBinOp, AtomicOrdering, AsmDialect}; use lib::llvm::{Opcode, IntPredicate, RealPredicate, True, False}; use lib::llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, ModuleRef}; use lib; @@ -872,12 +872,13 @@ pub fn add_comment(bcx: block, text: &str) { } } -pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char) -> ValueRef { +pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char, + dia: AsmDialect) -> ValueRef { unsafe { count_insn(cx, "inlineasm"); let llfty = T_fn(~[], T_void()); - let v = llvm::LLVMInlineAsm(llfty, asm, cons, False, False); + let v = llvm::LLVMInlineAsm(llfty, asm, cons, False, False, dia); Call(cx, v, ~[]) } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 9012d2587185c..737dd8c758a84 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -694,7 +694,7 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, ast::expr_inline_asm(asm, cons) => { do str::as_c_str(*asm) |a| { do str::as_c_str(*cons) |c| { - InlineAsmCall(bcx, a, c); + InlineAsmCall(bcx, a, c, lib::llvm::AD_ATT); } } return bcx; diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp index f5efed5f3a01d..7686dcd4ff4dc 100644 --- a/src/rustllvm/RustWrapper.cpp +++ b/src/rustllvm/RustWrapper.cpp @@ -545,9 +545,9 @@ extern "C" LLVMValueRef LLVMInlineAsm(LLVMTypeRef Ty, char *AsmString, char *Constraints, LLVMBool HasSideEffects, - LLVMBool IsAlignStack) { + LLVMBool IsAlignStack, + InlineAsm::AsmDialect Dialect) { return wrap(InlineAsm::get(unwrap(Ty), AsmString, Constraints, HasSideEffects, - IsAlignStack)); -// IsAlignStack, InlineAsm::AD_Intel)); + IsAlignStack, Dialect)); } From bcc6c3e3dbf4dc42129b46fba23be4f47c83e809 Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Sun, 10 Mar 2013 01:55:35 -0800 Subject: [PATCH 3/8] Require unsafe block for inline assembly. --- src/librustc/middle/typeck/check/mod.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index bd36eb1cf5603..e59dc1398a04e 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -2303,7 +2303,10 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let region_lb = ty::re_scope(expr.id); instantiate_path(fcx, pth, tpt, expr.span, expr.id, region_lb); } - ast::expr_inline_asm(*) => { fcx.write_nil(id); } + ast::expr_inline_asm(*) => { + fcx.require_unsafe(expr.span, ~"use of inline assembly"); + fcx.write_nil(id); + } ast::expr_mac(_) => tcx.sess.bug(~"unexpanded macro"), ast::expr_break(_) => { fcx.write_bot(id); bot = true; } ast::expr_again(_) => { fcx.write_bot(id); bot = true; } From 666e1b463600841ae593a1468a837dc59bb7cab5 Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Sun, 10 Mar 2013 22:08:38 -0700 Subject: [PATCH 4/8] Create asm! syntax extension. --- src/libsyntax/ext/asm.rs | 54 +++++++++++++++++++++++++++++++++++ src/libsyntax/ext/base.rs | 2 ++ src/libsyntax/print/pprust.rs | 2 +- src/libsyntax/syntax.rc | 1 + 4 files changed, 58 insertions(+), 1 deletion(-) create mode 100644 src/libsyntax/ext/asm.rs diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs new file mode 100644 index 0000000000000..bbf4238990720 --- /dev/null +++ b/src/libsyntax/ext/asm.rs @@ -0,0 +1,54 @@ +// Copyright 2012 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + + + +/* + * Inline assembly support. + */ + +use core::prelude::*; + +use ast; +use codemap::span; +use ext::base; +use ext::base::*; + +pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) + -> base::MacResult { + let args = get_exprs_from_tts(cx, tts); + if args.len() == 0 { + cx.span_fatal(sp, "ast! takes at least 1 argument."); + } + let asm = + expr_to_str(cx, args[0], + ~"inline assembly must be a string literal."); + let cons = if args.len() > 1 { + expr_to_str(cx, args[1], + ~"constraints must be a string literal.") + } else { ~"" }; + + MRExpr(@ast::expr { + id: cx.next_id(), + callee_id: cx.next_id(), + node: ast::expr_inline_asm(@asm, @cons), + span: sp + }) +} + +// +// Local Variables: +// mode: rust +// fill-column: 78; +// indent-tabs-mode: nil +// c-basic-offset: 4 +// buffer-file-coding-system: utf-8-unix +// End: +// diff --git a/src/libsyntax/ext/base.rs b/src/libsyntax/ext/base.rs index 23cabc099462f..1eae4b84cc992 100644 --- a/src/libsyntax/ext/base.rs +++ b/src/libsyntax/ext/base.rs @@ -198,6 +198,8 @@ pub fn syntax_expander_table() -> SyntaxEnv { ext::source_util::expand_mod)); syntax_expanders.insert(@~"proto", builtin_item_tt(ext::pipes::expand_proto)); + syntax_expanders.insert(@~"asm", + builtin_normal_tt(ext::asm::expand_asm)); syntax_expanders.insert( @~"trace_macros", builtin_normal_tt(ext::trace_macros::expand_trace_macros)); diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 350ab0cf9b297..25c18adb2fb96 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1402,7 +1402,7 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) { word(s.s, ~"__asm__"); popen(s); print_string(s, *a); - word_space(s, ~", "); + word_space(s, ~","); print_string(s, *c); pclose(s); } diff --git a/src/libsyntax/syntax.rc b/src/libsyntax/syntax.rc index 7f84d6a3010d9..e13ef976d976b 100644 --- a/src/libsyntax/syntax.rc +++ b/src/libsyntax/syntax.rc @@ -60,6 +60,7 @@ pub mod print { } pub mod ext { + pub mod asm; pub mod base; pub mod expand; From 885d0d3d3369bef72590a4d5671c0de83e968dda Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Sun, 10 Mar 2013 22:34:25 -0700 Subject: [PATCH 5/8] Stop parsing __asm__. --- src/etc/vim/syntax/rust.vim | 2 +- src/libsyntax/parse/parser.rs | 8 -------- src/libsyntax/parse/token.rs | 1 - 3 files changed, 1 insertion(+), 10 deletions(-) diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim index ccd1ddc243047..f811fbf585542 100644 --- a/src/etc/vim/syntax/rust.vim +++ b/src/etc/vim/syntax/rust.vim @@ -11,7 +11,7 @@ elseif exists("b:current_syntax") endif syn match rustAssert "\ HashMap<~str, ()> { pub fn strict_keyword_table() -> HashMap<~str, ()> { let words = HashMap(); let keys = ~[ - ~"__asm__", ~"as", ~"assert", ~"break", ~"const", ~"copy", From 5aa734d6a1946e526832bb602e1bb271bf26c0b1 Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Tue, 12 Mar 2013 00:01:09 -0700 Subject: [PATCH 6/8] Parse operands properly and add a way to indicate volatile asm. --- src/librustc/middle/trans/build.rs | 4 +- src/librustc/middle/trans/expr.rs | 8 +- src/libsyntax/ast.rs | 3 +- src/libsyntax/ext/asm.rs | 140 ++++++++++++++++++++++++++--- src/libsyntax/print/pprust.rs | 8 +- 5 files changed, 145 insertions(+), 18 deletions(-) diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index ad86b6c924539..2e6b0c5f78216 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -873,12 +873,12 @@ pub fn add_comment(bcx: block, text: &str) { } pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char, - dia: AsmDialect) -> ValueRef { + volatile: lib::llvm::Bool, dia: AsmDialect) -> ValueRef { unsafe { count_insn(cx, "inlineasm"); let llfty = T_fn(~[], T_void()); - let v = llvm::LLVMInlineAsm(llfty, asm, cons, False, False, dia); + let v = llvm::LLVMInlineAsm(llfty, asm, cons, volatile, False, dia); Call(cx, v, ~[]) } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 737dd8c758a84..0539dadca8e35 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -691,10 +691,14 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, ast::expr_assign_op(op, dst, src) => { return trans_assign_op(bcx, expr, op, dst, src); } - ast::expr_inline_asm(asm, cons) => { + ast::expr_inline_asm(asm, cons, volatile) => { + // XXX: cons doesn't actual contain ALL the stuff we should + // be passing since the constraints for in/outputs aren't included do str::as_c_str(*asm) |a| { do str::as_c_str(*cons) |c| { - InlineAsmCall(bcx, a, c, lib::llvm::AD_ATT); + let v = if volatile { lib::llvm::True } + else { lib::llvm::False }; + InlineAsmCall(bcx, a, c, v, lib::llvm::AD_ATT); } } return bcx; diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index b7c30360613f9..dab5de47aa648 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -601,7 +601,8 @@ pub enum expr_ { expr_ret(Option<@expr>), expr_log(log_level, @expr, @expr), - expr_inline_asm(@~str /* asm */, @~str /* constraints */), + /* asm, clobbers + constraints, volatile */ + expr_inline_asm(@~str, @~str, bool), expr_mac(mac), diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index bbf4238990720..229d1d2a95e1f 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -20,29 +20,147 @@ use ast; use codemap::span; use ext::base; use ext::base::*; +use parse; +use parse::token; + +enum State { + Asm, + Outputs, + Inputs, + Clobbers, + Options +} + +fn next_state(s: State) -> Option { + match s { + Asm => Some(Outputs), + Outputs => Some(Inputs), + Inputs => Some(Clobbers), + Clobbers => Some(Options), + Options => None + } +} pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) -> base::MacResult { - let args = get_exprs_from_tts(cx, tts); - if args.len() == 0 { - cx.span_fatal(sp, "ast! takes at least 1 argument."); + + let p = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), + vec::from_slice(tts)); + + let mut asm = ~""; + let mut outputs = ~[]; + let mut inputs = ~[]; + let mut cons = ~""; + let mut volatile = false; + + let mut state = Asm; + loop outer: { + + match state { + Asm => { + asm = expr_to_str(cx, p.parse_expr(), + ~"inline assembly must be a string literal."); + } + Outputs => { + while *p.token != token::EOF && + *p.token != token::COLON && + *p.token != token::MOD_SEP { + + if outputs.len() != 0 { + p.eat(&token::COMMA); + } + + let constraint = p.parse_str(); + p.expect(&token::LPAREN); + let out = p.parse_expr(); + p.expect(&token::RPAREN); + + outputs.push((constraint, out)); + } + } + Inputs => { + while *p.token != token::EOF && + *p.token != token::COLON && + *p.token != token::MOD_SEP { + + if inputs.len() != 0 { + p.eat(&token::COMMA); + } + + let constraint = p.parse_str(); + p.expect(&token::LPAREN); + let in = p.parse_expr(); + p.expect(&token::RPAREN); + + inputs.push((constraint, in)); + } + } + Clobbers => { + let mut clobs = ~[]; + while *p.token != token::EOF && + *p.token != token::COLON && + *p.token != token::MOD_SEP { + + if clobs.len() != 0 { + p.eat(&token::COMMA); + } + + let clob = ~"~{" + *p.parse_str() + ~"}"; + clobs.push(clob); + } + + cons = str::connect(clobs, ","); + } + Options => { + let option = *p.parse_str(); + + if option == ~"volatile" { + volatile = true; + } + + if *p.token == token::COMMA { + p.eat(&token::COMMA); + } + } + } + + while *p.token == token::COLON || + *p.token == token::MOD_SEP || + *p.token == token::EOF { + state = if *p.token == token::COLON { + p.bump(); + match next_state(state) { + Some(x) => x, + None => break outer + } + } else if *p.token == token::MOD_SEP { + p.bump(); + let s = match next_state(state) { + Some(x) => x, + None => break outer + }; + match next_state(s) { + Some(x) => x, + None => break outer + } + } else if *p.token == token::EOF { + break outer; + } else { + state + }; + } } - let asm = - expr_to_str(cx, args[0], - ~"inline assembly must be a string literal."); - let cons = if args.len() > 1 { - expr_to_str(cx, args[1], - ~"constraints must be a string literal.") - } else { ~"" }; MRExpr(@ast::expr { id: cx.next_id(), callee_id: cx.next_id(), - node: ast::expr_inline_asm(@asm, @cons), + node: ast::expr_inline_asm(@asm, @cons, volatile), span: sp }) } + + // // Local Variables: // mode: rust diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 25c18adb2fb96..6b1a72b92fff4 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1398,8 +1398,12 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) { } } } - ast::expr_inline_asm(a, c) => { - word(s.s, ~"__asm__"); + ast::expr_inline_asm(a, c, v) => { + if v { + word(s.s, ~"__volatile__ asm!"); + } else { + word(s.s, ~"asm!"); + } popen(s); print_string(s, *a); word_space(s, ~","); From 7f500ab4c1303723192952f9ae1f09290bc1fe1e Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Tue, 12 Mar 2013 00:09:53 -0700 Subject: [PATCH 7/8] Keep everything tidy. --- src/librustc/middle/typeck/check/mod.rs | 2 +- src/libsyntax/ast.rs | 2 +- src/libsyntax/ext/asm.rs | 17 ++++++++--------- 3 files changed, 10 insertions(+), 11 deletions(-) diff --git a/src/librustc/middle/typeck/check/mod.rs b/src/librustc/middle/typeck/check/mod.rs index e59dc1398a04e..445cab4ba95fd 100644 --- a/src/librustc/middle/typeck/check/mod.rs +++ b/src/librustc/middle/typeck/check/mod.rs @@ -2303,7 +2303,7 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt, let region_lb = ty::re_scope(expr.id); instantiate_path(fcx, pth, tpt, expr.span, expr.id, region_lb); } - ast::expr_inline_asm(*) => { + ast::expr_inline_asm(*) => { fcx.require_unsafe(expr.span, ~"use of inline assembly"); fcx.write_nil(id); } diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index dab5de47aa648..7b4b382393f6c 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -600,7 +600,7 @@ pub enum expr_ { expr_again(Option), expr_ret(Option<@expr>), expr_log(log_level, @expr, @expr), - + /* asm, clobbers + constraints, volatile */ expr_inline_asm(@~str, @~str, bool), diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 229d1d2a95e1f..3f1aea59ab502 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -55,7 +55,6 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) let mut state = Asm; loop outer: { - match state { Asm => { asm = expr_to_str(cx, p.parse_expr(), @@ -65,11 +64,11 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) while *p.token != token::EOF && *p.token != token::COLON && *p.token != token::MOD_SEP { - + if outputs.len() != 0 { p.eat(&token::COMMA); } - + let constraint = p.parse_str(); p.expect(&token::LPAREN); let out = p.parse_expr(); @@ -82,11 +81,11 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) while *p.token != token::EOF && *p.token != token::COLON && *p.token != token::MOD_SEP { - + if inputs.len() != 0 { p.eat(&token::COMMA); } - + let constraint = p.parse_str(); p.expect(&token::LPAREN); let in = p.parse_expr(); @@ -100,11 +99,11 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) while *p.token != token::EOF && *p.token != token::COLON && *p.token != token::MOD_SEP { - + if clobs.len() != 0 { p.eat(&token::COMMA); } - + let clob = ~"~{" + *p.parse_str() + ~"}"; clobs.push(clob); } @@ -113,7 +112,7 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) } Options => { let option = *p.parse_str(); - + if option == ~"volatile" { volatile = true; } @@ -146,7 +145,7 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) } else if *p.token == token::EOF { break outer; } else { - state + state }; } } From 18b71a78314505b4dd3816f9662709860aafaf4c Mon Sep 17 00:00:00 2001 From: Luqman Aden Date: Tue, 12 Mar 2013 01:02:58 -0700 Subject: [PATCH 8/8] Add alignstack option for inline asm. --- src/librustc/middle/trans/build.rs | 11 +++++++++-- src/librustc/middle/trans/expr.rs | 7 +++---- src/libsyntax/ast.rs | 4 ++-- src/libsyntax/ext/asm.rs | 5 ++++- src/libsyntax/print/pprust.rs | 2 +- 5 files changed, 19 insertions(+), 10 deletions(-) diff --git a/src/librustc/middle/trans/build.rs b/src/librustc/middle/trans/build.rs index 2e6b0c5f78216..50a7669a1be9f 100644 --- a/src/librustc/middle/trans/build.rs +++ b/src/librustc/middle/trans/build.rs @@ -873,12 +873,19 @@ pub fn add_comment(bcx: block, text: &str) { } pub fn InlineAsmCall(cx: block, asm: *c_char, cons: *c_char, - volatile: lib::llvm::Bool, dia: AsmDialect) -> ValueRef { + volatile: bool, alignstack: bool, + dia: AsmDialect) -> ValueRef { unsafe { count_insn(cx, "inlineasm"); + let volatile = if volatile { lib::llvm::True } + else { lib::llvm::False }; + let alignstack = if alignstack { lib::llvm::True } + else { lib::llvm::False }; + let llfty = T_fn(~[], T_void()); - let v = llvm::LLVMInlineAsm(llfty, asm, cons, volatile, False, dia); + let v = llvm::LLVMInlineAsm(llfty, asm, cons, volatile, + alignstack, dia); Call(cx, v, ~[]) } diff --git a/src/librustc/middle/trans/expr.rs b/src/librustc/middle/trans/expr.rs index 0539dadca8e35..c163183bfc8ef 100644 --- a/src/librustc/middle/trans/expr.rs +++ b/src/librustc/middle/trans/expr.rs @@ -691,14 +691,13 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr, ast::expr_assign_op(op, dst, src) => { return trans_assign_op(bcx, expr, op, dst, src); } - ast::expr_inline_asm(asm, cons, volatile) => { + ast::expr_inline_asm(asm, cons, volatile, alignstack) => { // XXX: cons doesn't actual contain ALL the stuff we should // be passing since the constraints for in/outputs aren't included do str::as_c_str(*asm) |a| { do str::as_c_str(*cons) |c| { - let v = if volatile { lib::llvm::True } - else { lib::llvm::False }; - InlineAsmCall(bcx, a, c, v, lib::llvm::AD_ATT); + InlineAsmCall(bcx, a, c, volatile, alignstack, + lib::llvm::AD_ATT); } } return bcx; diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 7b4b382393f6c..b22018c4c76e1 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -601,8 +601,8 @@ pub enum expr_ { expr_ret(Option<@expr>), expr_log(log_level, @expr, @expr), - /* asm, clobbers + constraints, volatile */ - expr_inline_asm(@~str, @~str, bool), + /* asm, clobbers + constraints, volatile, align stack */ + expr_inline_asm(@~str, @~str, bool, bool), expr_mac(mac), diff --git a/src/libsyntax/ext/asm.rs b/src/libsyntax/ext/asm.rs index 3f1aea59ab502..8051a67d8fdc7 100644 --- a/src/libsyntax/ext/asm.rs +++ b/src/libsyntax/ext/asm.rs @@ -52,6 +52,7 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) let mut inputs = ~[]; let mut cons = ~""; let mut volatile = false; + let mut alignstack = false; let mut state = Asm; loop outer: { @@ -115,6 +116,8 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) if option == ~"volatile" { volatile = true; + } else if option == ~"alignstack" { + alignstack = true; } if *p.token == token::COMMA { @@ -153,7 +156,7 @@ pub fn expand_asm(cx: ext_ctxt, sp: span, tts: &[ast::token_tree]) MRExpr(@ast::expr { id: cx.next_id(), callee_id: cx.next_id(), - node: ast::expr_inline_asm(@asm, @cons, volatile), + node: ast::expr_inline_asm(@asm, @cons, volatile, alignstack), span: sp }) } diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index 6b1a72b92fff4..9288312378206 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -1398,7 +1398,7 @@ pub fn print_expr(s: @ps, &&expr: @ast::expr) { } } } - ast::expr_inline_asm(a, c, v) => { + ast::expr_inline_asm(a, c, v, _) => { if v { word(s.s, ~"__volatile__ asm!"); } else {