1 //! Declare various LLVM values.
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.
7 //! Some useful guidelines:
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.
14 use crate::abi::{FnAbi, FnAbiLlvmExt};
15 use crate::attributes;
16 use crate::context::CodegenCx;
18 use crate::llvm::AttributePlace::Function;
19 use crate::type_::Type;
20 use crate::value::Value;
21 use rustc_codegen_ssa::traits::TypeMembershipMethods;
22 use rustc_middle::ty::Ty;
23 use rustc_symbol_mangling::typeid::typeid_for_fnabi;
24 use smallvec::SmallVec;
26 /// Declare a function.
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<'ll>(
31 cx: &CodegenCx<'ll, '_>,
33 callconv: llvm::CallConv,
34 unnamed: llvm::UnnamedAddr,
35 visibility: llvm::Visibility,
38 debug!("declare_raw_fn(name={:?}, ty={:?})", name, ty);
40 llvm::LLVMRustGetOrInsertFunction(cx.llmod, name.as_ptr().cast(), name.len(), ty)
43 llvm::SetFunctionCallConv(llfn, callconv);
44 llvm::SetUnnamedAddress(llfn, unnamed);
45 llvm::set_visibility(llfn, visibility);
47 let mut attrs = SmallVec::<[_; 4]>::new();
49 if cx.tcx.sess.opts.cg.no_redzone.unwrap_or(cx.tcx.sess.target.disable_redzone) {
50 attrs.push(llvm::AttributeKind::NoRedZone.create_attr(cx.llcx));
53 attrs.extend(attributes::non_lazy_bind_attr(cx));
55 attributes::apply_to_llfn(llfn, Function, &attrs);
60 impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
61 /// Declare a global value.
63 /// If there’s a value with the same name already declared, the function will
64 /// return its Value instead.
65 pub fn declare_global(&self, name: &str, ty: &'ll Type) -> &'ll Value {
66 debug!("declare_global(name={:?})", name);
67 unsafe { llvm::LLVMRustGetOrInsertGlobal(self.llmod, name.as_ptr().cast(), name.len(), ty) }
70 /// Declare a C ABI function.
72 /// Only use this for foreign function ABIs and glue. For Rust functions use
73 /// `declare_fn` instead.
75 /// If there’s a value with the same name already declared, the function will
76 /// update the declaration and return existing Value instead.
80 unnamed: llvm::UnnamedAddr,
83 // Declare C ABI functions with the visibility used by C by default.
84 let visibility = if self.tcx.sess.target.default_hidden_visibility {
85 llvm::Visibility::Hidden
87 llvm::Visibility::Default
90 declare_raw_fn(self, name, llvm::CCallConv, unnamed, visibility, fn_type)
93 /// Declare an entry Function
95 /// The ABI of this function can change depending on the target (although for now the same as
98 /// If there’s a value with the same name already declared, the function will
99 /// update the declaration and return existing Value instead.
100 pub fn declare_entry_fn(
103 callconv: llvm::CallConv,
104 unnamed: llvm::UnnamedAddr,
107 let visibility = if self.tcx.sess.target.default_hidden_visibility {
108 llvm::Visibility::Hidden
110 llvm::Visibility::Default
112 declare_raw_fn(self, name, callconv, unnamed, visibility, fn_type)
115 /// Declare a Rust function.
117 /// If there’s a value with the same name already declared, the function will
118 /// update the declaration and return existing Value instead.
119 pub fn declare_fn(&self, name: &str, fn_abi: &FnAbi<'tcx, Ty<'tcx>>) -> &'ll Value {
120 debug!("declare_rust_fn(name={:?}, fn_abi={:?})", name, fn_abi);
122 // Function addresses in Rust are never significant, allowing functions to
124 let llfn = declare_raw_fn(
128 llvm::UnnamedAddr::Global,
129 llvm::Visibility::Default,
130 fn_abi.llvm_type(self),
132 fn_abi.apply_attrs_llfn(self, llfn);
134 if self.tcx.sess.is_sanitizer_cfi_enabled() {
135 let typeid = typeid_for_fnabi(self.tcx, fn_abi);
136 self.set_type_metadata(llfn, typeid);
142 /// Declare a global with an intention to define it.
144 /// Use this function when you intend to define a global. This function will
145 /// return `None` if the name already has a definition associated with it. In that
146 /// case an error should be reported to the user, because it usually happens due
147 /// to user’s fault (e.g., misuse of `#[no_mangle]` or `#[export_name]` attributes).
148 pub fn define_global(&self, name: &str, ty: &'ll Type) -> Option<&'ll Value> {
149 if self.get_defined_value(name).is_some() {
152 Some(self.declare_global(name, ty))
156 /// Declare a private global
158 /// Use this function when you intend to define a global without a name.
159 pub fn define_private_global(&self, ty: &'ll Type) -> &'ll Value {
160 unsafe { llvm::LLVMRustInsertPrivateGlobal(self.llmod, ty) }
163 /// Gets declared value by name.
164 pub fn get_declared_value(&self, name: &str) -> Option<&'ll Value> {
165 debug!("get_declared_value(name={:?})", name);
166 unsafe { llvm::LLVMRustGetNamedValue(self.llmod, name.as_ptr().cast(), name.len()) }
169 /// Gets defined or externally defined (AvailableExternally linkage) value by
171 pub fn get_defined_value(&self, name: &str) -> Option<&'ll Value> {
172 self.get_declared_value(name).and_then(|val| {
173 let declaration = unsafe { llvm::LLVMIsDeclaration(val) != 0 };
174 if !declaration { Some(val) } else { None }