compiler/rustc_codegen_llvm/src/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, CString};
  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 AddFunctionAttributes<'ll>(llfn: &'ll Value, idx: AttributePlace, attrs: &[&'ll Attribute]) {
  35     unsafe {
  36         LLVMRustAddFunctionAttributes(llfn, idx.as_uint(), attrs.as_ptr(), attrs.len());
  37     }
  38 }
  39
  40 pub fn AddCallSiteAttributes<'ll>(
  41     callsite: &'ll Value,
  42     idx: AttributePlace,
  43     attrs: &[&'ll Attribute],
  44 ) {
  45     unsafe {
  46         LLVMRustAddCallSiteAttributes(callsite, idx.as_uint(), attrs.as_ptr(), attrs.len());
  47     }
  48 }
  49
  50 pub fn CreateAttrStringValue<'ll>(llcx: &'ll Context, attr: &str, value: &str) -> &'ll Attribute {
  51     unsafe {
  52         LLVMCreateStringAttribute(
  53             llcx,
  54             attr.as_ptr().cast(),
  55             attr.len().try_into().unwrap(),
  56             value.as_ptr().cast(),
  57             value.len().try_into().unwrap(),
  58         )
  59     }
  60 }
  61
  62 pub fn CreateAttrString<'ll>(llcx: &'ll Context, attr: &str) -> &'ll Attribute {
  63     unsafe {
  64         LLVMCreateStringAttribute(
  65             llcx,
  66             attr.as_ptr().cast(),
  67             attr.len().try_into().unwrap(),
  68             std::ptr::null(),
  69             0,
  70         )
  71     }
  72 }
  73
  74 pub fn CreateAlignmentAttr(llcx: &Context, bytes: u64) -> &Attribute {
  75     unsafe { LLVMRustCreateAlignmentAttr(llcx, bytes) }
  76 }
  77
  78 pub fn CreateDereferenceableAttr(llcx: &Context, bytes: u64) -> &Attribute {
  79     unsafe { LLVMRustCreateDereferenceableAttr(llcx, bytes) }
  80 }
  81
  82 pub fn CreateDereferenceableOrNullAttr(llcx: &Context, bytes: u64) -> &Attribute {
  83     unsafe { LLVMRustCreateDereferenceableOrNullAttr(llcx, bytes) }
  84 }
  85
  86 pub fn CreateByValAttr<'ll>(llcx: &'ll Context, ty: &'ll Type) -> &'ll Attribute {
  87     unsafe { LLVMRustCreateByValAttr(llcx, ty) }
  88 }
  89
  90 pub fn CreateStructRetAttr<'ll>(llcx: &'ll Context, ty: &'ll Type) -> &'ll Attribute {
  91     unsafe { LLVMRustCreateStructRetAttr(llcx, ty) }
  92 }
  93
  94 pub fn CreateUWTableAttr(llcx: &Context, async_: bool) -> &Attribute {
  95     unsafe { LLVMRustCreateUWTableAttr(llcx, async_) }
  96 }
  97
  98 pub fn CreateAllocSizeAttr(llcx: &Context, size_arg: u32) -> &Attribute {
  99     unsafe { LLVMRustCreateAllocSizeAttr(llcx, size_arg) }
 100 }
 101
 102 pub fn CreateAllocKindAttr(llcx: &Context, kind_arg: AllocKindFlags) -> &Attribute {
 103     unsafe { LLVMRustCreateAllocKindAttr(llcx, kind_arg.bits()) }
 104 }
 105
 106 #[derive(Copy, Clone)]
 107 pub enum AttributePlace {
 108     ReturnValue,
 109     Argument(u32),
 110     Function,
 111 }
 112
 113 impl AttributePlace {
 114     pub fn as_uint(self) -> c_uint {
 115         match self {
 116             AttributePlace::ReturnValue => 0,
 117             AttributePlace::Argument(i) => 1 + i,
 118             AttributePlace::Function => !0,
 119         }
 120     }
 121 }
 122
 123 #[derive(Copy, Clone, PartialEq)]
 124 #[repr(C)]
 125 pub enum CodeGenOptSize {
 126     CodeGenOptSizeNone = 0,
 127     CodeGenOptSizeDefault = 1,
 128     CodeGenOptSizeAggressive = 2,
 129 }
 130
 131 impl FromStr for ArchiveKind {
 132     type Err = ();
 133
 134     fn from_str(s: &str) -> Result<Self, Self::Err> {
 135         match s {
 136             "gnu" => Ok(ArchiveKind::K_GNU),
 137             "bsd" => Ok(ArchiveKind::K_BSD),
 138             "darwin" => Ok(ArchiveKind::K_DARWIN),
 139             "coff" => Ok(ArchiveKind::K_COFF),
 140             _ => Err(()),
 141         }
 142     }
 143 }
 144
 145 pub fn SetInstructionCallConv(instr: &Value, cc: CallConv) {
 146     unsafe {
 147         LLVMSetInstructionCallConv(instr, cc as c_uint);
 148     }
 149 }
 150 pub fn SetFunctionCallConv(fn_: &Value, cc: CallConv) {
 151     unsafe {
 152         LLVMSetFunctionCallConv(fn_, cc as c_uint);
 153     }
 154 }
 155
 156 // Externally visible symbols that might appear in multiple codegen units need to appear in
 157 // their own comdat section so that the duplicates can be discarded at link time. This can for
 158 // example happen for generics when using multiple codegen units. This function simply uses the
 159 // value's name as the comdat value to make sure that it is in a 1-to-1 relationship to the
 160 // function.
 161 // For more details on COMDAT sections see e.g., https://www.airs.com/blog/archives/52
 162 pub fn SetUniqueComdat(llmod: &Module, val: &Value) {
 163     unsafe {
 164         let name = get_value_name(val);
 165         LLVMRustSetComdat(llmod, val, name.as_ptr().cast(), name.len());
 166     }
 167 }
 168
 169 pub fn SetUnnamedAddress(global: &Value, unnamed: UnnamedAddr) {
 170     unsafe {
 171         LLVMSetUnnamedAddress(global, unnamed);
 172     }
 173 }
 174
 175 pub fn set_thread_local_mode(global: &Value, mode: ThreadLocalMode) {
 176     unsafe {
 177         LLVMSetThreadLocalMode(global, mode);
 178     }
 179 }
 180
 181 impl AttributeKind {
 182     /// Create an LLVM Attribute with no associated value.
 183     pub fn create_attr(self, llcx: &Context) -> &Attribute {
 184         unsafe { LLVMRustCreateAttrNoValue(llcx, self) }
 185     }
 186 }
 187
 188 impl MemoryEffects {
 189     /// Create an LLVM Attribute with these memory effects.
 190     pub fn create_attr(self, llcx: &Context) -> &Attribute {
 191         unsafe { LLVMRustCreateMemoryEffectsAttr(llcx, self) }
 192     }
 193 }
 194
 195 pub fn set_section(llglobal: &Value, section_name: &str) {
 196     let section_name_cstr = CString::new(section_name).expect("unexpected CString error");
 197     unsafe {
 198         LLVMSetSection(llglobal, section_name_cstr.as_ptr());
 199     }
 200 }
 201
 202 pub fn add_global<'a>(llmod: &'a Module, ty: &'a Type, name: &str) -> &'a Value {
 203     let name_cstr = CString::new(name).expect("unexpected CString error");
 204     unsafe { LLVMAddGlobal(llmod, ty, name_cstr.as_ptr()) }
 205 }
 206
 207 pub fn set_initializer(llglobal: &Value, constant_val: &Value) {
 208     unsafe {
 209         LLVMSetInitializer(llglobal, constant_val);
 210     }
 211 }
 212
 213 pub fn set_global_constant(llglobal: &Value, is_constant: bool) {
 214     unsafe {
 215         LLVMSetGlobalConstant(llglobal, if is_constant { ffi::True } else { ffi::False });
 216     }
 217 }
 218
 219 pub fn set_linkage(llglobal: &Value, linkage: Linkage) {
 220     unsafe {
 221         LLVMRustSetLinkage(llglobal, linkage);
 222     }
 223 }
 224
 225 pub fn set_visibility(llglobal: &Value, visibility: Visibility) {
 226     unsafe {
 227         LLVMRustSetVisibility(llglobal, visibility);
 228     }
 229 }
 230
 231 pub fn set_alignment(llglobal: &Value, bytes: usize) {
 232     unsafe {
 233         ffi::LLVMSetAlignment(llglobal, bytes as c_uint);
 234     }
 235 }
 236
 237 pub fn set_comdat(llmod: &Module, llglobal: &Value, name: &str) {
 238     unsafe {
 239         LLVMRustSetComdat(llmod, llglobal, name.as_ptr().cast(), name.len());
 240     }
 241 }
 242
 243 /// Safe wrapper around `LLVMGetParam`, because segfaults are no fun.
 244 pub fn get_param(llfn: &Value, index: c_uint) -> &Value {
 245     unsafe {
 246         assert!(
 247             index < LLVMCountParams(llfn),
 248             "out of bounds argument access: {} out of {} arguments",
 249             index,
 250             LLVMCountParams(llfn)
 251         );
 252         LLVMGetParam(llfn, index)
 253     }
 254 }
 255
 256 /// Safe wrapper for `LLVMGetValueName2` into a byte slice
 257 pub fn get_value_name(value: &Value) -> &[u8] {
 258     unsafe {
 259         let mut len = 0;
 260         let data = LLVMGetValueName2(value, &mut len);
 261         std::slice::from_raw_parts(data.cast(), len)
 262     }
 263 }
 264
 265 /// Safe wrapper for `LLVMSetValueName2` from a byte slice
 266 pub fn set_value_name(value: &Value, name: &[u8]) {
 267     unsafe {
 268         let data = name.as_ptr().cast();
 269         LLVMSetValueName2(value, data, name.len());
 270     }
 271 }
 272
 273 pub fn build_string(f: impl FnOnce(&RustString)) -> Result<String, FromUtf8Error> {
 274     let sr = RustString { bytes: RefCell::new(Vec::new()) };
 275     f(&sr);
 276     String::from_utf8(sr.bytes.into_inner())
 277 }
 278
 279 pub fn build_byte_buffer(f: impl FnOnce(&RustString)) -> Vec<u8> {
 280     let sr = RustString { bytes: RefCell::new(Vec::new()) };
 281     f(&sr);
 282     sr.bytes.into_inner()
 283 }
 284
 285 pub fn twine_to_string(tr: &Twine) -> String {
 286     unsafe {
 287         build_string(|s| LLVMRustWriteTwineToString(tr, s)).expect("got a non-UTF8 Twine from LLVM")
 288     }
 289 }
 290
 291 pub fn last_error() -> Option<String> {
 292     unsafe {
 293         let cstr = LLVMRustGetLastError();
 294         if cstr.is_null() {
 295             None
 296         } else {
 297             let err = CStr::from_ptr(cstr).to_bytes();
 298             let err = String::from_utf8_lossy(err).to_string();
 299             libc::free(cstr as *mut _);
 300             Some(err)
 301         }
 302     }
 303 }
 304
 305 pub struct OperandBundleDef<'a> {
 306     pub raw: &'a mut ffi::OperandBundleDef<'a>,
 307 }
 308
 309 impl<'a> OperandBundleDef<'a> {
 310     pub fn new(name: &str, vals: &[&'a Value]) -> Self {
 311         let name = SmallCStr::new(name);
 312         let def = unsafe {
 313             LLVMRustBuildOperandBundleDef(name.as_ptr(), vals.as_ptr(), vals.len() as c_uint)
 314         };
 315         OperandBundleDef { raw: def }
 316     }
 317 }
 318
 319 impl Drop for OperandBundleDef<'_> {
 320     fn drop(&mut self) {
 321         unsafe {
 322             LLVMRustFreeOperandBundleDef(&mut *(self.raw as *mut _));
 323         }
 324     }
 325 }