src/librustc_codegen_llvm/declare.rs

   1 //! Declare various LLVM values.
   2 //!
   3 //! Prefer using functions and methods from this module rather than calling LLVM
   4 //! functions directly. These functions do some additional work to ensure we do
   5 //! the right thing given the preconceptions of codegen.
   6 //!
   7 //! Some useful guidelines:
   8 //!
   9 //! * Use declare_* family of methods if you are declaring, but are not
  10 //!   interested in defining the Value they return.
  11 //! * Use define_* family of methods when you might be defining the Value.
  12 //! * When in doubt, define.
  13
  14 use crate::abi::{FnAbi, FnAbiLlvmExt};
  15 use crate::attributes;
  16 use crate::context::CodegenCx;
  17 use crate::llvm;
  18 use crate::llvm::AttributePlace::Function;
  19 use crate::type_::Type;
  20 use crate::value::Value;
  21 use log::debug;
  22 use rustc::ty::Ty;
  23 use rustc_codegen_ssa::traits::*;
  24 use rustc_data_structures::small_c_str::SmallCStr;
  25
  26 /// Declare a function.
  27 ///
  28 /// If there’s a value with the same name already declared, the function will
  29 /// update the declaration and return existing Value instead.
  30 fn declare_raw_fn(
  31     cx: &CodegenCx<'ll, '_>,
  32     name: &str,
  33     callconv: llvm::CallConv,
  34     ty: &'ll Type,
  35 ) -> &'ll Value {
  36     debug!("declare_raw_fn(name={:?}, ty={:?})", name, ty);
  37     let namebuf = SmallCStr::new(name);
  38     let llfn = unsafe { llvm::LLVMRustGetOrInsertFunction(cx.llmod, namebuf.as_ptr(), ty) };
  39
  40     llvm::SetFunctionCallConv(llfn, callconv);
  41     // Function addresses in Rust are never significant, allowing functions to
  42     // be merged.
  43     llvm::SetUnnamedAddr(llfn, true);
  44
  45     if cx.tcx.sess.opts.cg.no_redzone.unwrap_or(cx.tcx.sess.target.target.options.disable_redzone) {
  46         llvm::Attribute::NoRedZone.apply_llfn(Function, llfn);
  47     }
  48
  49     attributes::default_optimisation_attrs(cx.tcx.sess, llfn);
  50     attributes::non_lazy_bind(cx.sess(), llfn);
  51     llfn
  52 }
  53
  54 impl DeclareMethods<'tcx> for CodegenCx<'ll, 'tcx> {
  55     fn declare_global(&self, name: &str, ty: &'ll Type) -> &'ll Value {
  56         debug!("declare_global(name={:?})", name);
  57         unsafe { llvm::LLVMRustGetOrInsertGlobal(self.llmod, name.as_ptr().cast(), name.len(), ty) }
  58     }
  59
  60     fn declare_cfn(&self, name: &str, fn_type: &'ll Type) -> &'ll Value {
  61         declare_raw_fn(self, name, llvm::CCallConv, fn_type)
  62     }
  63
  64     fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> &'ll Value {
  65         debug!("declare_rust_fn(name={:?}, fn_abi={:?})", name, fn_abi);
  66
  67         let llfn = declare_raw_fn(self, name, fn_abi.llvm_cconv(), fn_abi.llvm_type(self));
  68         fn_abi.apply_attrs_llfn(self, llfn);
  69         llfn
  70     }
  71
  72     fn define_global(&self, name: &str, ty: &'ll Type) -> Option<&'ll Value> {
  73         if self.get_defined_value(name).is_some() {
  74             None
  75         } else {
  76             Some(self.declare_global(name, ty))
  77         }
  78     }
  79
  80     fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
  81         unsafe { llvm::LLVMRustInsertPrivateGlobal(self.llmod, ty) }
  82     }
  83
  84     fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
  85         debug!("get_declared_value(name={:?})", name);
  86         let namebuf = SmallCStr::new(name);
  87         unsafe { llvm::LLVMRustGetNamedValue(self.llmod, namebuf.as_ptr()) }
  88     }
  89
  90     fn get_defined_value(&self, name: &str) -> Option<&'ll Value> {
  91         self.get_declared_value(name).and_then(|val| {
  92             let declaration = unsafe { llvm::LLVMIsDeclaration(val) != 0 };
  93             if !declaration { Some(val) } else { None }
  94         })
  95     }
  96 }