src/librustc_codegen_llvm/llvm/mod.rs

   1 #![allow(non_snake_case)]
   2
   3 pub use self::AtomicRmwBinOp::*;
   4 pub use self::CallConv::*;
   5 pub use self::CodeGenOptSize::*;
   6 pub use self::IntPredicate::*;
   7 pub use self::Linkage::*;
   8 pub use self::MetadataType::*;
   9 pub use self::RealPredicate::*;
  10
  11 use libc::c_uint;
  12 use rustc_data_structures::small_c_str::SmallCStr;
  13 use rustc_llvm::RustString;
  14 use std::cell::RefCell;
  15 use std::ffi::CStr;
  16 use std::str::FromStr;
  17 use std::string::FromUtf8Error;
  18
  19 pub mod archive_ro;
  20 pub mod diagnostic;
  21 mod ffi;
  22
  23 pub use self::ffi::*;
  24
  25 impl LLVMRustResult {
  26     pub fn into_result(self) -> Result<(), ()> {
  27         match self {
  28             LLVMRustResult::Success => Ok(()),
  29             LLVMRustResult::Failure => Err(()),
  30         }
  31     }
  32 }
  33
  34 pub fn AddFunctionAttrStringValue(llfn: &'a Value, idx: AttributePlace, attr: &CStr, value: &CStr) {
  35     unsafe {
  36         LLVMRustAddFunctionAttrStringValue(llfn, idx.as_uint(), attr.as_ptr(), value.as_ptr())
  37     }
  38 }
  39
  40 #[derive(Copy, Clone)]
  41 pub enum AttributePlace {
  42     ReturnValue,
  43     Argument(u32),
  44     Function,
  45 }
  46
  47 impl AttributePlace {
  48     pub fn as_uint(self) -> c_uint {
  49         match self {
  50             AttributePlace::ReturnValue => 0,
  51             AttributePlace::Argument(i) => 1 + i,
  52             AttributePlace::Function => !0,
  53         }
  54     }
  55 }
  56
  57 #[derive(Copy, Clone, PartialEq)]
  58 #[repr(C)]
  59 pub enum CodeGenOptSize {
  60     CodeGenOptSizeNone = 0,
  61     CodeGenOptSizeDefault = 1,
  62     CodeGenOptSizeAggressive = 2,
  63 }
  64
  65 impl FromStr for ArchiveKind {
  66     type Err = ();
  67
  68     fn from_str(s: &str) -> Result<Self, Self::Err> {
  69         match s {
  70             "gnu" => Ok(ArchiveKind::K_GNU),
  71             "bsd" => Ok(ArchiveKind::K_BSD),
  72             "darwin" => Ok(ArchiveKind::K_DARWIN),
  73             "coff" => Ok(ArchiveKind::K_COFF),
  74             _ => Err(()),
  75         }
  76     }
  77 }
  78
  79 pub fn SetInstructionCallConv(instr: &'a Value, cc: CallConv) {
  80     unsafe {
  81         LLVMSetInstructionCallConv(instr, cc as c_uint);
  82     }
  83 }
  84 pub fn SetFunctionCallConv(fn_: &'a Value, cc: CallConv) {
  85     unsafe {
  86         LLVMSetFunctionCallConv(fn_, cc as c_uint);
  87     }
  88 }
  89
  90 // Externally visible symbols that might appear in multiple codegen units need to appear in
  91 // their own comdat section so that the duplicates can be discarded at link time. This can for
  92 // example happen for generics when using multiple codegen units. This function simply uses the
  93 // value's name as the comdat value to make sure that it is in a 1-to-1 relationship to the
  94 // function.
  95 // For more details on COMDAT sections see e.g., http://www.airs.com/blog/archives/52
  96 pub fn SetUniqueComdat(llmod: &Module, val: &'a Value) {
  97     unsafe {
  98         let name = get_value_name(val);
  99         LLVMRustSetComdat(llmod, val, name.as_ptr().cast(), name.len());
 100     }
 101 }
 102
 103 pub fn UnsetComdat(val: &'a Value) {
 104     unsafe {
 105         LLVMRustUnsetComdat(val);
 106     }
 107 }
 108
 109 pub fn SetUnnamedAddr(global: &'a Value, unnamed: bool) {
 110     unsafe {
 111         LLVMSetUnnamedAddr(global, unnamed as Bool);
 112     }
 113 }
 114
 115 pub fn set_thread_local(global: &'a Value, is_thread_local: bool) {
 116     unsafe {
 117         LLVMSetThreadLocal(global, is_thread_local as Bool);
 118     }
 119 }
 120 pub fn set_thread_local_mode(global: &'a Value, mode: ThreadLocalMode) {
 121     unsafe {
 122         LLVMSetThreadLocalMode(global, mode);
 123     }
 124 }
 125
 126 impl Attribute {
 127     pub fn apply_llfn(&self, idx: AttributePlace, llfn: &Value) {
 128         unsafe { LLVMRustAddFunctionAttribute(llfn, idx.as_uint(), *self) }
 129     }
 130
 131     pub fn apply_callsite(&self, idx: AttributePlace, callsite: &Value) {
 132         unsafe { LLVMRustAddCallSiteAttribute(callsite, idx.as_uint(), *self) }
 133     }
 134
 135     pub fn unapply_llfn(&self, idx: AttributePlace, llfn: &Value) {
 136         unsafe { LLVMRustRemoveFunctionAttributes(llfn, idx.as_uint(), *self) }
 137     }
 138
 139     pub fn toggle_llfn(&self, idx: AttributePlace, llfn: &Value, set: bool) {
 140         if set {
 141             self.apply_llfn(idx, llfn);
 142         } else {
 143             self.unapply_llfn(idx, llfn);
 144         }
 145     }
 146 }
 147
 148 // Memory-managed interface to object files.
 149
 150 pub struct ObjectFile {
 151     pub llof: &'static mut ffi::ObjectFile,
 152 }
 153
 154 unsafe impl Send for ObjectFile {}
 155
 156 impl ObjectFile {
 157     // This will take ownership of llmb
 158     pub fn new(llmb: &'static mut MemoryBuffer) -> Option<ObjectFile> {
 159         unsafe {
 160             let llof = LLVMCreateObjectFile(llmb)?;
 161             Some(ObjectFile { llof })
 162         }
 163     }
 164 }
 165
 166 impl Drop for ObjectFile {
 167     fn drop(&mut self) {
 168         unsafe {
 169             LLVMDisposeObjectFile(&mut *(self.llof as *mut _));
 170         }
 171     }
 172 }
 173
 174 // Memory-managed interface to section iterators.
 175
 176 pub struct SectionIter<'a> {
 177     pub llsi: &'a mut SectionIterator<'a>,
 178 }
 179
 180 impl Drop for SectionIter<'a> {
 181     fn drop(&mut self) {
 182         unsafe {
 183             LLVMDisposeSectionIterator(&mut *(self.llsi as *mut _));
 184         }
 185     }
 186 }
 187
 188 pub fn mk_section_iter(llof: &'a ffi::ObjectFile) -> SectionIter<'a> {
 189     unsafe { SectionIter { llsi: LLVMGetSections(llof) } }
 190 }
 191
 192 /// Safe wrapper around `LLVMGetParam`, because segfaults are no fun.
 193 pub fn get_param(llfn: &'a Value, index: c_uint) -> &'a Value {
 194     unsafe {
 195         assert!(
 196             index < LLVMCountParams(llfn),
 197             "out of bounds argument access: {} out of {} arguments",
 198             index,
 199             LLVMCountParams(llfn)
 200         );
 201         LLVMGetParam(llfn, index)
 202     }
 203 }
 204
 205 /// Safe wrapper for `LLVMGetValueName2` into a byte slice
 206 pub fn get_value_name(value: &'a Value) -> &'a [u8] {
 207     unsafe {
 208         let mut len = 0;
 209         let data = LLVMGetValueName2(value, &mut len);
 210         std::slice::from_raw_parts(data.cast(), len)
 211     }
 212 }
 213
 214 /// Safe wrapper for `LLVMSetValueName2` from a byte slice
 215 pub fn set_value_name(value: &Value, name: &[u8]) {
 216     unsafe {
 217         let data = name.as_ptr().cast();
 218         LLVMSetValueName2(value, data, name.len());
 219     }
 220 }
 221
 222 pub fn build_string(f: impl FnOnce(&RustString)) -> Result<String, FromUtf8Error> {
 223     let sr = RustString { bytes: RefCell::new(Vec::new()) };
 224     f(&sr);
 225     String::from_utf8(sr.bytes.into_inner())
 226 }
 227
 228 pub fn twine_to_string(tr: &Twine) -> String {
 229     unsafe {
 230         build_string(|s| LLVMRustWriteTwineToString(tr, s)).expect("got a non-UTF8 Twine from LLVM")
 231     }
 232 }
 233
 234 pub fn last_error() -> Option<String> {
 235     unsafe {
 236         let cstr = LLVMRustGetLastError();
 237         if cstr.is_null() {
 238             None
 239         } else {
 240             let err = CStr::from_ptr(cstr).to_bytes();
 241             let err = String::from_utf8_lossy(err).to_string();
 242             libc::free(cstr as *mut _);
 243             Some(err)
 244         }
 245     }
 246 }
 247
 248 pub struct OperandBundleDef<'a> {
 249     pub raw: &'a mut ffi::OperandBundleDef<'a>,
 250 }
 251
 252 impl OperandBundleDef<'a> {
 253     pub fn new(name: &str, vals: &[&'a Value]) -> Self {
 254         let name = SmallCStr::new(name);
 255         let def = unsafe {
 256             LLVMRustBuildOperandBundleDef(name.as_ptr(), vals.as_ptr(), vals.len() as c_uint)
 257         };
 258         OperandBundleDef { raw: def }
 259     }
 260 }
 261
 262 impl Drop for OperandBundleDef<'a> {
 263     fn drop(&mut self) {
 264         unsafe {
 265             LLVMRustFreeOperandBundleDef(&mut *(self.raw as *mut _));
 266         }
 267     }
 268 }