2014-05-28 14:36:05 -05:00
|
|
|
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
|
2013-03-27 14:50:57 -05:00
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
|
|
|
/*!
|
|
|
|
# Translation of inline assembly.
|
|
|
|
*/
|
|
|
|
|
2014-07-07 19:58:01 -05:00
|
|
|
use llvm;
|
2014-11-15 19:30:33 -06:00
|
|
|
use trans::build::*;
|
|
|
|
use trans::callee;
|
|
|
|
use trans::common::*;
|
|
|
|
use trans::cleanup;
|
|
|
|
use trans::cleanup::CleanupMethods;
|
|
|
|
use trans::expr;
|
|
|
|
use trans::type_of;
|
|
|
|
use trans::type_::Type;
|
2013-06-16 05:52:44 -05:00
|
|
|
|
2014-03-08 14:36:22 -06:00
|
|
|
use std::c_str::ToCStr;
|
2014-05-22 18:57:53 -05:00
|
|
|
use std::string::String;
|
2013-03-27 14:50:57 -05:00
|
|
|
use syntax::ast;
|
2014-09-27 03:33:36 -05:00
|
|
|
use libc::{c_uint, c_char};
|
2013-03-27 14:50:57 -05:00
|
|
|
|
|
|
|
// Take an inline assembly expression and splat it out via LLVM
|
2014-09-06 11:13:04 -05:00
|
|
|
pub fn trans_inline_asm<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, ia: &ast::InlineAsm)
|
|
|
|
-> Block<'blk, 'tcx> {
|
2014-01-15 13:39:08 -06:00
|
|
|
let fcx = bcx.fcx;
|
2013-03-27 14:50:57 -05:00
|
|
|
let mut bcx = bcx;
|
2014-03-04 12:02:49 -06:00
|
|
|
let mut constraints = Vec::new();
|
|
|
|
let mut output_types = Vec::new();
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-01-15 13:39:08 -06:00
|
|
|
let temp_scope = fcx.push_custom_cleanup_scope();
|
|
|
|
|
2014-08-19 14:39:26 -05:00
|
|
|
let mut ext_inputs = Vec::new();
|
|
|
|
let mut ext_constraints = Vec::new();
|
|
|
|
|
2013-03-27 14:50:57 -05:00
|
|
|
// Prepare the output operands
|
2014-08-19 14:39:26 -05:00
|
|
|
let outputs = ia.outputs.iter().enumerate().map(|(i, &(ref c, ref out, is_rw))| {
|
2014-01-15 20:30:40 -06:00
|
|
|
constraints.push((*c).clone());
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-05-16 12:15:33 -05:00
|
|
|
let out_datum = unpack_datum!(bcx, expr::trans(bcx, &**out));
|
2014-01-15 13:39:08 -06:00
|
|
|
output_types.push(type_of::type_of(bcx.ccx(), out_datum.ty));
|
2014-08-19 14:39:26 -05:00
|
|
|
let val = out_datum.val;
|
|
|
|
if is_rw {
|
|
|
|
ext_inputs.push(unpack_result!(bcx, {
|
|
|
|
callee::trans_arg_datum(bcx,
|
|
|
|
expr_ty(bcx, &**out),
|
|
|
|
out_datum,
|
|
|
|
cleanup::CustomScope(temp_scope),
|
|
|
|
callee::DontAutorefArg)
|
|
|
|
}));
|
|
|
|
ext_constraints.push(i.to_string());
|
|
|
|
}
|
|
|
|
val
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-03-28 14:42:34 -05:00
|
|
|
}).collect::<Vec<_>>();
|
2013-03-27 14:50:57 -05:00
|
|
|
|
|
|
|
// Now the input operands
|
2014-10-15 01:05:01 -05:00
|
|
|
let mut inputs = ia.inputs.iter().map(|&(ref c, ref input)| {
|
2014-01-15 20:30:40 -06:00
|
|
|
constraints.push((*c).clone());
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-05-16 12:15:33 -05:00
|
|
|
let in_datum = unpack_datum!(bcx, expr::trans(bcx, &**input));
|
2013-03-27 14:50:57 -05:00
|
|
|
unpack_result!(bcx, {
|
2014-03-06 11:24:11 -06:00
|
|
|
callee::trans_arg_datum(bcx,
|
2014-09-07 12:09:06 -05:00
|
|
|
expr_ty(bcx, &**input),
|
|
|
|
in_datum,
|
|
|
|
cleanup::CustomScope(temp_scope),
|
|
|
|
callee::DontAutorefArg)
|
2013-03-27 14:50:57 -05:00
|
|
|
})
|
2014-10-15 01:05:01 -05:00
|
|
|
}).collect::<Vec<_>>();
|
|
|
|
inputs.push_all(ext_inputs.as_slice());
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-01-15 13:39:08 -06:00
|
|
|
// no failure occurred preparing operands, no need to cleanup
|
|
|
|
fcx.pop_custom_cleanup_scope(temp_scope);
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-04-02 18:54:22 -05:00
|
|
|
let mut constraints =
|
2014-05-22 18:57:53 -05:00
|
|
|
String::from_str(constraints.iter()
|
2014-05-25 05:17:19 -05:00
|
|
|
.map(|s| s.get().to_string())
|
2014-09-14 22:27:36 -05:00
|
|
|
.chain(ext_constraints.into_iter())
|
2014-05-22 18:57:53 -05:00
|
|
|
.collect::<Vec<String>>()
|
2014-05-19 19:23:26 -05:00
|
|
|
.connect(",")
|
|
|
|
.as_slice());
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-05-28 14:36:05 -05:00
|
|
|
let mut clobbers = get_clobbers();
|
2014-01-15 20:30:40 -06:00
|
|
|
if !ia.clobbers.get().is_empty() && !clobbers.is_empty() {
|
2014-05-27 22:44:58 -05:00
|
|
|
clobbers = format!("{},{}", ia.clobbers.get(), clobbers);
|
2013-03-27 17:37:28 -05:00
|
|
|
} else {
|
2014-01-15 20:30:40 -06:00
|
|
|
clobbers.push_str(ia.clobbers.get());
|
2013-10-17 13:24:41 -05:00
|
|
|
}
|
2013-03-27 17:37:28 -05:00
|
|
|
|
2013-03-27 14:50:57 -05:00
|
|
|
// Add the clobbers to our constraints list
|
2013-06-11 21:13:42 -05:00
|
|
|
if clobbers.len() != 0 && constraints.len() != 0 {
|
2014-10-15 01:05:01 -05:00
|
|
|
constraints.push(',');
|
2014-04-02 18:54:22 -05:00
|
|
|
constraints.push_str(clobbers.as_slice());
|
2013-03-27 14:50:57 -05:00
|
|
|
} else {
|
2014-04-02 18:54:22 -05:00
|
|
|
constraints.push_str(clobbers.as_slice());
|
2013-03-27 14:50:57 -05:00
|
|
|
}
|
|
|
|
|
2014-10-15 01:25:34 -05:00
|
|
|
debug!("Asm Constraints: {}", constraints.as_slice());
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2014-02-15 15:15:03 -06:00
|
|
|
let num_outputs = outputs.len();
|
2013-03-27 14:50:57 -05:00
|
|
|
|
|
|
|
// Depending on how many outputs we have, the return type is different
|
2014-02-15 15:15:03 -06:00
|
|
|
let output_type = if num_outputs == 0 {
|
2014-03-15 15:29:34 -05:00
|
|
|
Type::void(bcx.ccx())
|
2014-02-15 15:15:03 -06:00
|
|
|
} else if num_outputs == 1 {
|
2014-10-15 01:05:01 -05:00
|
|
|
output_types[0]
|
2013-03-27 14:50:57 -05:00
|
|
|
} else {
|
2014-03-15 15:29:34 -05:00
|
|
|
Type::struct_(bcx.ccx(), output_types.as_slice(), false)
|
2013-03-27 14:50:57 -05:00
|
|
|
};
|
|
|
|
|
2013-03-27 16:42:19 -05:00
|
|
|
let dialect = match ia.dialect {
|
2014-07-07 19:58:01 -05:00
|
|
|
ast::AsmAtt => llvm::AD_ATT,
|
|
|
|
ast::AsmIntel => llvm::AD_Intel
|
2013-03-27 16:42:19 -05:00
|
|
|
};
|
|
|
|
|
2014-01-15 20:30:40 -06:00
|
|
|
let r = ia.asm.get().with_c_str(|a| {
|
2014-04-02 18:54:22 -05:00
|
|
|
constraints.as_slice().with_c_str(|c| {
|
2014-02-28 17:25:15 -06:00
|
|
|
InlineAsmCall(bcx,
|
|
|
|
a,
|
|
|
|
c,
|
|
|
|
inputs.as_slice(),
|
|
|
|
output_type,
|
|
|
|
ia.volatile,
|
|
|
|
ia.alignstack,
|
|
|
|
dialect)
|
2013-11-21 17:42:55 -06:00
|
|
|
})
|
|
|
|
});
|
2013-03-27 14:50:57 -05:00
|
|
|
|
2013-03-28 18:34:10 -05:00
|
|
|
// Again, based on how many outputs we have
|
2014-02-15 15:15:03 -06:00
|
|
|
if num_outputs == 1 {
|
2014-10-15 01:05:01 -05:00
|
|
|
Store(bcx, r, outputs[0]);
|
2013-03-27 14:50:57 -05:00
|
|
|
} else {
|
2013-10-17 13:24:41 -05:00
|
|
|
for (i, o) in outputs.iter().enumerate() {
|
2013-03-27 14:50:57 -05:00
|
|
|
let v = ExtractValue(bcx, r, i);
|
2013-10-17 13:24:41 -05:00
|
|
|
Store(bcx, v, *o);
|
2013-03-27 14:50:57 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-27 03:33:36 -05:00
|
|
|
// Store expn_id in a metadata node so we can map LLVM errors
|
|
|
|
// back to source locations. See #17552.
|
|
|
|
unsafe {
|
|
|
|
let key = "srcloc";
|
|
|
|
let kind = llvm::LLVMGetMDKindIDInContext(bcx.ccx().llcx(),
|
|
|
|
key.as_ptr() as *const c_char, key.len() as c_uint);
|
|
|
|
|
2014-09-28 11:25:48 -05:00
|
|
|
let val: llvm::ValueRef = C_i32(bcx.ccx(), ia.expn_id.to_llvm_cookie());
|
2014-09-27 03:33:36 -05:00
|
|
|
|
|
|
|
llvm::LLVMSetMetadata(r, kind,
|
|
|
|
llvm::LLVMMDNodeInContext(bcx.ccx().llcx(), &val, 1));
|
|
|
|
}
|
|
|
|
|
2013-03-27 14:50:57 -05:00
|
|
|
return bcx;
|
|
|
|
|
|
|
|
}
|
2013-03-27 17:37:28 -05:00
|
|
|
|
|
|
|
// Default per-arch clobbers
|
|
|
|
// Basically what clang does
|
|
|
|
|
2014-09-29 01:39:03 -05:00
|
|
|
#[cfg(any(target_arch = "arm",
|
|
|
|
target_arch = "mips",
|
|
|
|
target_arch = "mipsel"))]
|
2014-05-28 14:36:05 -05:00
|
|
|
fn get_clobbers() -> String {
|
2014-05-25 05:17:19 -05:00
|
|
|
"".to_string()
|
2013-03-27 17:37:28 -05:00
|
|
|
}
|
|
|
|
|
2014-09-29 01:39:03 -05:00
|
|
|
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
|
2014-05-28 14:36:05 -05:00
|
|
|
fn get_clobbers() -> String {
|
2014-05-25 05:17:19 -05:00
|
|
|
"~{dirflag},~{fpsr},~{flags}".to_string()
|
2013-03-27 17:37:28 -05:00
|
|
|
}
|