src/librustc_codegen_llvm/callee.rs

   1 //! Handles codegen of callees as well as other call-related
   2 //! things. Callees are a superset of normal rust values and sometimes
   3 //! have different representations. In particular, top-level fn items
   4 //! and methods are represented as just a fn ptr and not a full
   5 //! closure.
   6
   7 use crate::attributes;
   8 use crate::llvm;
   9 use crate::monomorphize::Instance;
  10 use crate::context::CodegenCx;
  11 use crate::value::Value;
  12 use rustc_codegen_ssa::traits::*;
  13
  14 use rustc::ty::TypeFoldable;
  15 use rustc::ty::layout::{LayoutOf, HasTyCtxt};
  16
  17 /// Codegens a reference to a fn/method item, monomorphizing and
  18 /// inlining as it goes.
  19 ///
  20 /// # Parameters
  21 ///
  22 /// - `cx`: the crate context
  23 /// - `instance`: the instance to be instantiated
  24 pub fn get_fn(
  25     cx: &CodegenCx<'ll, 'tcx>,
  26     instance: Instance<'tcx>,
  27 ) -> &'ll Value {
  28     let tcx = cx.tcx();
  29
  30     debug!("get_fn(instance={:?})", instance);
  31
  32     assert!(!instance.substs.needs_infer());
  33     assert!(!instance.substs.has_escaping_bound_vars());
  34     assert!(!instance.substs.has_param_types());
  35
  36     let sig = instance.fn_sig(cx.tcx());
  37     if let Some(&llfn) = cx.instances().borrow().get(&instance) {
  38         return llfn;
  39     }
  40
  41     let sym = tcx.symbol_name(instance).as_str();
  42     debug!("get_fn({:?}: {:?}) => {}", instance, sig, sym);
  43
  44     // Create a fn pointer with the substituted signature.
  45     let fn_ptr_ty = tcx.mk_fn_ptr(sig);
  46     let llptrty = cx.backend_type(cx.layout_of(fn_ptr_ty));
  47
  48     let llfn = if let Some(llfn) = cx.get_declared_value(&sym) {
  49         // This is subtle and surprising, but sometimes we have to bitcast
  50         // the resulting fn pointer.  The reason has to do with external
  51         // functions.  If you have two crates that both bind the same C
  52         // library, they may not use precisely the same types: for
  53         // example, they will probably each declare their own structs,
  54         // which are distinct types from LLVM's point of view (nominal
  55         // types).
  56         //
  57         // Now, if those two crates are linked into an application, and
  58         // they contain inlined code, you can wind up with a situation
  59         // where both of those functions wind up being loaded into this
  60         // application simultaneously. In that case, the same function
  61         // (from LLVM's point of view) requires two types. But of course
  62         // LLVM won't allow one function to have two types.
  63         //
  64         // What we currently do, therefore, is declare the function with
  65         // one of the two types (whichever happens to come first) and then
  66         // bitcast as needed when the function is referenced to make sure
  67         // it has the type we expect.
  68         //
  69         // This can occur on either a crate-local or crate-external
  70         // reference. It also occurs when testing libcore and in some
  71         // other weird situations. Annoying.
  72         if cx.val_ty(llfn) != llptrty {
  73             debug!("get_fn: casting {:?} to {:?}", llfn, llptrty);
  74             cx.const_ptrcast(llfn, llptrty)
  75         } else {
  76             debug!("get_fn: not casting pointer!");
  77             llfn
  78         }
  79     } else {
  80         let llfn = cx.declare_fn(&sym, sig);
  81         assert_eq!(cx.val_ty(llfn), llptrty);
  82         debug!("get_fn: not casting pointer!");
  83
  84         if instance.def.is_inline(tcx) {
  85             attributes::inline(cx, llfn, attributes::InlineAttr::Hint);
  86         }
  87         attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id()), sig);
  88
  89         let instance_def_id = instance.def_id();
  90
  91         // Apply an appropriate linkage/visibility value to our item that we
  92         // just declared.
  93         //
  94         // This is sort of subtle. Inside our codegen unit we started off
  95         // compilation by predefining all our own `MonoItem` instances. That
  96         // is, everything we're codegenning ourselves is already defined. That
  97         // means that anything we're actually codegenning in this codegen unit
  98         // will have hit the above branch in `get_declared_value`. As a result,
  99         // we're guaranteed here that we're declaring a symbol that won't get
 100         // defined, or in other words we're referencing a value from another
 101         // codegen unit or even another crate.
 102         //
 103         // So because this is a foreign value we blanket apply an external
 104         // linkage directive because it's coming from a different object file.
 105         // The visibility here is where it gets tricky. This symbol could be
 106         // referencing some foreign crate or foreign library (an `extern`
 107         // block) in which case we want to leave the default visibility. We may
 108         // also, though, have multiple codegen units. It could be a
 109         // monomorphization, in which case its expected visibility depends on
 110         // whether we are sharing generics or not. The important thing here is
 111         // that the visibility we apply to the declaration is the same one that
 112         // has been applied to the definition (wherever that definition may be).
 113         unsafe {
 114             llvm::LLVMRustSetLinkage(llfn, llvm::Linkage::ExternalLinkage);
 115
 116             let is_generic = instance.substs.non_erasable_generics().next().is_some();
 117
 118             if is_generic {
 119                 // This is a monomorphization. Its expected visibility depends
 120                 // on whether we are in share-generics mode.
 121
 122                 if cx.tcx.sess.opts.share_generics() {
 123                     // We are in share_generics mode.
 124
 125                     if instance_def_id.is_local() {
 126                         // This is a definition from the current crate. If the
 127                         // definition is unreachable for downstream crates or
 128                         // the current crate does not re-export generics, the
 129                         // definition of the instance will have been declared
 130                         // as `hidden`.
 131                         if cx.tcx.is_unreachable_local_definition(instance_def_id) ||
 132                            !cx.tcx.local_crate_exports_generics() {
 133                             llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden);
 134                         }
 135                     } else {
 136                         // This is a monomorphization of a generic function
 137                         // defined in an upstream crate.
 138                         if cx.tcx.upstream_monomorphizations_for(instance_def_id)
 139                                  .map(|set| set.contains_key(instance.substs))
 140                                  .unwrap_or(false) {
 141                             // This is instantiated in another crate. It cannot
 142                             // be `hidden`.
 143                         } else {
 144                             // This is a local instantiation of an upstream definition.
 145                             // If the current crate does not re-export it
 146                             // (because it is a C library or an executable), it
 147                             // will have been declared `hidden`.
 148                             if !cx.tcx.local_crate_exports_generics() {
 149                                 llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden);
 150                             }
 151                         }
 152                     }
 153                 } else {
 154                     // When not sharing generics, all instances are in the same
 155                     // crate and have hidden visibility
 156                     llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden);
 157                 }
 158             } else {
 159                 // This is a non-generic function
 160                 if cx.tcx.is_codegened_item(instance_def_id) {
 161                     // This is a function that is instantiated in the local crate
 162
 163                     if instance_def_id.is_local() {
 164                         // This is function that is defined in the local crate.
 165                         // If it is not reachable, it is hidden.
 166                         if !cx.tcx.is_reachable_non_generic(instance_def_id) {
 167                             llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden);
 168                         }
 169                     } else {
 170                         // This is a function from an upstream crate that has
 171                         // been instantiated here. These are always hidden.
 172                         llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden);
 173                     }
 174                 }
 175             }
 176         }
 177
 178         if cx.use_dll_storage_attrs &&
 179             tcx.is_dllimport_foreign_item(instance_def_id)
 180         {
 181             unsafe {
 182                 llvm::LLVMSetDLLStorageClass(llfn, llvm::DLLStorageClass::DllImport);
 183             }
 184         }
 185
 186         llfn
 187     };
 188
 189     cx.instances.borrow_mut().insert(instance, llfn);
 190
 191     llfn
 192 }