1 // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
12 use llvm
::{ContextRef, ModuleRef, ValueRef}
;
13 use rustc
::dep_graph
::{DepGraph
, DepGraphSafe
, DepNode
, DepTrackingMap
,
14 DepTrackingMapConfig
, WorkProduct
};
15 use middle
::cstore
::LinkMeta
;
17 use rustc
::hir
::def
::ExportMap
;
18 use rustc
::hir
::def_id
::DefId
;
24 use glue
::DropGlueKind
;
25 use monomorphize
::Instance
;
27 use partitioning
::CodegenUnit
;
28 use trans_item
::TransItem
;
30 use rustc_data_structures
::base_n
;
31 use rustc
::ty
::subst
::Substs
;
32 use rustc
::ty
::{self, Ty, TyCtxt}
;
33 use session
::config
::NoDebugInfo
;
36 use symbol_map
::SymbolMap
;
37 use util
::nodemap
::{NodeSet, DefIdMap, FxHashMap, FxHashSet}
;
39 use std
::ffi
::{CStr, CString}
;
40 use std
::cell
::{Cell, RefCell}
;
41 use std
::marker
::PhantomData
;
47 use syntax
::symbol
::InternedString
;
48 use syntax_pos
::DUMMY_SP
;
49 use abi
::{Abi, FnType}
;
52 pub n_glues_created
: Cell
<usize>,
53 pub n_null_glues
: Cell
<usize>,
54 pub n_real_glues
: Cell
<usize>,
55 pub n_fns
: Cell
<usize>,
56 pub n_inlines
: Cell
<usize>,
57 pub n_closures
: Cell
<usize>,
58 pub n_llvm_insns
: Cell
<usize>,
59 pub llvm_insns
: RefCell
<FxHashMap
<String
, usize>>,
60 // (ident, llvm-instructions)
61 pub fn_stats
: RefCell
<Vec
<(String
, usize)> >,
64 /// The shared portion of a `CrateContext`. There is one `SharedCrateContext`
65 /// per crate. The data here is shared between all compilation units of the
66 /// crate, so it must not contain references to any LLVM data structures
67 /// (aside from metadata-related ones).
68 pub struct SharedCrateContext
<'a
, 'tcx
: 'a
> {
69 metadata_llmod
: ModuleRef
,
70 metadata_llcx
: ContextRef
,
72 export_map
: ExportMap
,
73 exported_symbols
: NodeSet
,
75 tcx
: TyCtxt
<'a
, 'tcx
, 'tcx
>,
76 empty_param_env
: ty
::ParameterEnvironment
<'tcx
>,
80 use_dll_storage_attrs
: bool
,
82 translation_items
: RefCell
<FxHashSet
<TransItem
<'tcx
>>>,
83 trait_cache
: RefCell
<DepTrackingMap
<TraitSelectionCache
<'tcx
>>>,
84 project_cache
: RefCell
<DepTrackingMap
<ProjectionCache
<'tcx
>>>,
87 /// The local portion of a `CrateContext`. There is one `LocalCrateContext`
88 /// per compilation unit. Each one has its own LLVM `ContextRef` so that
89 /// several compilation units may be optimized in parallel. All other LLVM
90 /// data structures in the `LocalCrateContext` are tied to that `ContextRef`.
91 pub struct LocalCrateContext
<'tcx
> {
94 previous_work_product
: Option
<WorkProduct
>,
95 codegen_unit
: CodegenUnit
<'tcx
>,
96 needs_unwind_cleanup_cache
: RefCell
<FxHashMap
<Ty
<'tcx
>, bool
>>,
97 fn_pointer_shims
: RefCell
<FxHashMap
<Ty
<'tcx
>, ValueRef
>>,
98 drop_glues
: RefCell
<FxHashMap
<DropGlueKind
<'tcx
>, (ValueRef
, FnType
)>>,
99 /// Cache instances of monomorphic and polymorphic items
100 instances
: RefCell
<FxHashMap
<Instance
<'tcx
>, ValueRef
>>,
101 /// Cache generated vtables
102 vtables
: RefCell
<FxHashMap
<(ty
::Ty
<'tcx
>,
103 Option
<ty
::PolyExistentialTraitRef
<'tcx
>>), ValueRef
>>,
104 /// Cache of constant strings,
105 const_cstr_cache
: RefCell
<FxHashMap
<InternedString
, ValueRef
>>,
107 /// Reverse-direction for const ptrs cast from globals.
108 /// Key is a ValueRef holding a *T,
109 /// Val is a ValueRef holding a *[T].
111 /// Needed because LLVM loses pointer->pointee association
112 /// when we ptrcast, and we have to ptrcast during translation
113 /// of a [T] const because we form a slice, a (*T,usize) pair, not
114 /// a pointer to an LLVM array type. Similar for trait objects.
115 const_unsized
: RefCell
<FxHashMap
<ValueRef
, ValueRef
>>,
117 /// Cache of emitted const globals (value -> global)
118 const_globals
: RefCell
<FxHashMap
<ValueRef
, ValueRef
>>,
120 /// Cache of emitted const values
121 const_values
: RefCell
<FxHashMap
<(ast
::NodeId
, &'tcx Substs
<'tcx
>), ValueRef
>>,
123 /// Cache of external const values
124 extern_const_values
: RefCell
<DefIdMap
<ValueRef
>>,
126 /// Mapping from static definitions to their DefId's.
127 statics
: RefCell
<FxHashMap
<ValueRef
, DefId
>>,
129 impl_method_cache
: RefCell
<FxHashMap
<(DefId
, ast
::Name
), DefId
>>,
131 /// Cache of closure wrappers for bare fn's.
132 closure_bare_wrapper_cache
: RefCell
<FxHashMap
<ValueRef
, ValueRef
>>,
134 /// List of globals for static variables which need to be passed to the
135 /// LLVM function ReplaceAllUsesWith (RAUW) when translation is complete.
136 /// (We have to make sure we don't invalidate any ValueRefs referring
138 statics_to_rauw
: RefCell
<Vec
<(ValueRef
, ValueRef
)>>,
140 lltypes
: RefCell
<FxHashMap
<Ty
<'tcx
>, Type
>>,
141 llsizingtypes
: RefCell
<FxHashMap
<Ty
<'tcx
>, Type
>>,
142 type_hashcodes
: RefCell
<FxHashMap
<Ty
<'tcx
>, String
>>,
144 opaque_vec_type
: Type
,
145 str_slice_type
: Type
,
147 /// Holds the LLVM values for closure IDs.
148 closure_vals
: RefCell
<FxHashMap
<Instance
<'tcx
>, ValueRef
>>,
150 dbg_cx
: Option
<debuginfo
::CrateDebugContext
<'tcx
>>,
152 eh_personality
: Cell
<Option
<ValueRef
>>,
153 eh_unwind_resume
: Cell
<Option
<ValueRef
>>,
154 rust_try_fn
: Cell
<Option
<ValueRef
>>,
156 intrinsics
: RefCell
<FxHashMap
<&'
static str, ValueRef
>>,
158 /// Depth of the current type-of computation - used to bail out
159 type_of_depth
: Cell
<usize>,
161 symbol_map
: Rc
<SymbolMap
<'tcx
>>,
163 /// A counter that is used for generating local symbol names
164 local_gen_sym_counter
: Cell
<usize>,
167 // Implement DepTrackingMapConfig for `trait_cache`
168 pub struct TraitSelectionCache
<'tcx
> {
169 data
: PhantomData
<&'
tcx ()>
172 impl<'tcx
> DepTrackingMapConfig
for TraitSelectionCache
<'tcx
> {
173 type Key
= ty
::PolyTraitRef
<'tcx
>;
174 type Value
= traits
::Vtable
<'tcx
, ()>;
175 fn to_dep_node(key
: &ty
::PolyTraitRef
<'tcx
>) -> DepNode
<DefId
> {
176 key
.to_poly_trait_predicate().dep_node()
182 pub struct ProjectionCache
<'gcx
> {
183 data
: PhantomData
<&'
gcx ()>
186 impl<'gcx
> DepTrackingMapConfig
for ProjectionCache
<'gcx
> {
188 type Value
= Ty
<'gcx
>;
189 fn to_dep_node(key
: &Self::Key
) -> DepNode
<DefId
> {
190 // Ideally, we'd just put `key` into the dep-node, but we
191 // can't put full types in there. So just collect up all the
192 // def-ids of structs/enums as well as any traits that we
193 // project out of. It doesn't matter so much what we do here,
194 // except that if we are too coarse, we'll create overly
195 // coarse edges between impls and the trans. For example, if
196 // we just used the def-id of things we are projecting out of,
197 // then the key for `<Foo as SomeTrait>::T` and `<Bar as
198 // SomeTrait>::T` would both share a dep-node
199 // (`TraitSelect(SomeTrait)`), and hence the impls for both
200 // `Foo` and `Bar` would be considered inputs. So a change to
201 // `Bar` would affect things that just normalized `Foo`.
202 // Anyway, this heuristic is not ideal, but better than
204 let def_ids
: Vec
<DefId
> =
206 .filter_map(|t
| match t
.sty
{
207 ty
::TyAdt(adt_def
, _
) => Some(adt_def
.did
),
208 ty
::TyProjection(ref proj
) => Some(proj
.trait_ref
.def_id
),
213 DepNode
::ProjectionCache { def_ids: def_ids }
217 /// This list owns a number of LocalCrateContexts and binds them to their common
218 /// SharedCrateContext. This type just exists as a convenience, something to
219 /// pass around all LocalCrateContexts with and get an iterator over them.
220 pub struct CrateContextList
<'a
, 'tcx
: 'a
> {
221 shared
: &'a SharedCrateContext
<'a
, 'tcx
>,
222 local_ccxs
: Vec
<LocalCrateContext
<'tcx
>>,
225 impl<'a
, 'tcx
: 'a
> CrateContextList
<'a
, 'tcx
> {
226 pub fn new(shared_ccx
: &'a SharedCrateContext
<'a
, 'tcx
>,
227 codegen_units
: Vec
<CodegenUnit
<'tcx
>>,
228 previous_work_products
: Vec
<Option
<WorkProduct
>>,
229 symbol_map
: Rc
<SymbolMap
<'tcx
>>)
230 -> CrateContextList
<'a
, 'tcx
> {
233 local_ccxs
: codegen_units
.into_iter().zip(previous_work_products
).map(|(cgu
, wp
)| {
234 LocalCrateContext
::new(shared_ccx
, cgu
, wp
, symbol_map
.clone())
239 /// Iterate over all crate contexts, whether or not they need
240 /// translation. That is, whether or not a `.o` file is available
241 /// for re-use from a previous incr. comp.).
242 pub fn iter_all
<'b
>(&'b
self) -> CrateContextIterator
<'b
, 'tcx
> {
243 CrateContextIterator
{
246 local_ccxs
: &self.local_ccxs
[..],
247 filter_to_previous_work_product_unavail
: false,
251 /// Iterator over all CCX that need translation (cannot reuse results from
252 /// previous incr. comp.).
253 pub fn iter_need_trans
<'b
>(&'b
self) -> CrateContextIterator
<'b
, 'tcx
> {
254 CrateContextIterator
{
257 local_ccxs
: &self.local_ccxs
[..],
258 filter_to_previous_work_product_unavail
: true,
262 pub fn shared(&self) -> &'a SharedCrateContext
<'a
, 'tcx
> {
267 /// A CrateContext value binds together one LocalCrateContext with the
268 /// SharedCrateContext. It exists as a convenience wrapper, so we don't have to
269 /// pass around (SharedCrateContext, LocalCrateContext) tuples all over trans.
270 pub struct CrateContext
<'a
, 'tcx
: 'a
> {
271 shared
: &'a SharedCrateContext
<'a
, 'tcx
>,
272 local_ccxs
: &'a
[LocalCrateContext
<'tcx
>],
273 /// The index of `local` in `local_ccxs`. This is used in
274 /// `maybe_iter(true)` to identify the original `LocalCrateContext`.
278 impl<'a
, 'tcx
> DepGraphSafe
for CrateContext
<'a
, 'tcx
> {
281 pub struct CrateContextIterator
<'a
, 'tcx
: 'a
> {
282 shared
: &'a SharedCrateContext
<'a
, 'tcx
>,
283 local_ccxs
: &'a
[LocalCrateContext
<'tcx
>],
286 /// if true, only return results where `previous_work_product` is none
287 filter_to_previous_work_product_unavail
: bool
,
290 impl<'a
, 'tcx
> Iterator
for CrateContextIterator
<'a
,'tcx
> {
291 type Item
= CrateContext
<'a
, 'tcx
>;
293 fn next(&mut self) -> Option
<CrateContext
<'a
, 'tcx
>> {
295 if self.index
>= self.local_ccxs
.len() {
299 let index
= self.index
;
302 let ccx
= CrateContext
{
305 local_ccxs
: self.local_ccxs
,
309 self.filter_to_previous_work_product_unavail
&&
310 ccx
.previous_work_product().is_some()
320 pub fn get_reloc_model(sess
: &Session
) -> llvm
::RelocMode
{
321 let reloc_model_arg
= match sess
.opts
.cg
.relocation_model
{
322 Some(ref s
) => &s
[..],
323 None
=> &sess
.target
.target
.options
.relocation_model
[..],
326 match ::back
::write
::RELOC_MODEL_ARGS
.iter().find(
327 |&&arg
| arg
.0 == reloc_model_arg
) {
330 sess
.err(&format
!("{:?} is not a valid relocation mode",
334 sess
.abort_if_errors();
340 fn is_any_library(sess
: &Session
) -> bool
{
341 sess
.crate_types
.borrow().iter().any(|ty
| {
342 *ty
!= config
::CrateTypeExecutable
346 pub fn is_pie_binary(sess
: &Session
) -> bool
{
347 !is_any_library(sess
) && get_reloc_model(sess
) == llvm
::RelocMode
::PIC
350 unsafe fn create_context_and_module(sess
: &Session
, mod_name
: &str) -> (ContextRef
, ModuleRef
) {
351 let llcx
= llvm
::LLVMContextCreate();
352 let mod_name
= CString
::new(mod_name
).unwrap();
353 let llmod
= llvm
::LLVMModuleCreateWithNameInContext(mod_name
.as_ptr(), llcx
);
355 // Ensure the data-layout values hardcoded remain the defaults.
356 if sess
.target
.target
.options
.is_builtin
{
357 let tm
= ::back
::write
::create_target_machine(sess
);
358 llvm
::LLVMRustSetDataLayoutFromTargetMachine(llmod
, tm
);
359 llvm
::LLVMRustDisposeTargetMachine(tm
);
361 let data_layout
= llvm
::LLVMGetDataLayout(llmod
);
362 let data_layout
= str::from_utf8(CStr
::from_ptr(data_layout
).to_bytes())
363 .ok().expect("got a non-UTF8 data-layout from LLVM");
365 // Unfortunately LLVM target specs change over time, and right now we
366 // don't have proper support to work with any more than one
367 // `data_layout` than the one that is in the rust-lang/rust repo. If
368 // this compiler is configured against a custom LLVM, we may have a
369 // differing data layout, even though we should update our own to use
372 // As an interim hack, if CFG_LLVM_ROOT is not an empty string then we
373 // disable this check entirely as we may be configured with something
374 // that has a different target layout.
376 // Unsure if this will actually cause breakage when rustc is configured
380 let cfg_llvm_root
= option_env
!("CFG_LLVM_ROOT").unwrap_or("");
381 let custom_llvm_used
= cfg_llvm_root
.trim() != "";
383 if !custom_llvm_used
&& sess
.target
.target
.data_layout
!= data_layout
{
384 bug
!("data-layout for builtin `{}` target, `{}`, \
385 differs from LLVM default, `{}`",
386 sess
.target
.target
.llvm_target
,
387 sess
.target
.target
.data_layout
,
392 let data_layout
= CString
::new(&sess
.target
.target
.data_layout
[..]).unwrap();
393 llvm
::LLVMSetDataLayout(llmod
, data_layout
.as_ptr());
395 let llvm_target
= sess
.target
.target
.llvm_target
.as_bytes();
396 let llvm_target
= CString
::new(llvm_target
).unwrap();
397 llvm
::LLVMRustSetNormalizedTarget(llmod
, llvm_target
.as_ptr());
399 if is_pie_binary(sess
) {
400 llvm
::LLVMRustSetModulePIELevel(llmod
);
406 impl<'b
, 'tcx
> SharedCrateContext
<'b
, 'tcx
> {
407 pub fn new(tcx
: TyCtxt
<'b
, 'tcx
, 'tcx
>,
408 export_map
: ExportMap
,
410 exported_symbols
: NodeSet
,
411 check_overflow
: bool
)
412 -> SharedCrateContext
<'b
, 'tcx
> {
413 let (metadata_llcx
, metadata_llmod
) = unsafe {
414 create_context_and_module(&tcx
.sess
, "metadata")
417 // An interesting part of Windows which MSVC forces our hand on (and
418 // apparently MinGW didn't) is the usage of `dllimport` and `dllexport`
419 // attributes in LLVM IR as well as native dependencies (in C these
420 // correspond to `__declspec(dllimport)`).
422 // Whenever a dynamic library is built by MSVC it must have its public
423 // interface specified by functions tagged with `dllexport` or otherwise
424 // they're not available to be linked against. This poses a few problems
425 // for the compiler, some of which are somewhat fundamental, but we use
426 // the `use_dll_storage_attrs` variable below to attach the `dllexport`
427 // attribute to all LLVM functions that are exported e.g. they're
428 // already tagged with external linkage). This is suboptimal for a few
431 // * If an object file will never be included in a dynamic library,
432 // there's no need to attach the dllexport attribute. Most object
433 // files in Rust are not destined to become part of a dll as binaries
434 // are statically linked by default.
435 // * If the compiler is emitting both an rlib and a dylib, the same
436 // source object file is currently used but with MSVC this may be less
437 // feasible. The compiler may be able to get around this, but it may
438 // involve some invasive changes to deal with this.
440 // The flipside of this situation is that whenever you link to a dll and
441 // you import a function from it, the import should be tagged with
442 // `dllimport`. At this time, however, the compiler does not emit
443 // `dllimport` for any declarations other than constants (where it is
444 // required), which is again suboptimal for even more reasons!
446 // * Calling a function imported from another dll without using
447 // `dllimport` causes the linker/compiler to have extra overhead (one
448 // `jmp` instruction on x86) when calling the function.
449 // * The same object file may be used in different circumstances, so a
450 // function may be imported from a dll if the object is linked into a
451 // dll, but it may be just linked against if linked into an rlib.
452 // * The compiler has no knowledge about whether native functions should
453 // be tagged dllimport or not.
455 // For now the compiler takes the perf hit (I do not have any numbers to
456 // this effect) by marking very little as `dllimport` and praying the
457 // linker will take care of everything. Fixing this problem will likely
458 // require adding a few attributes to Rust itself (feature gated at the
459 // start) and then strongly recommending static linkage on MSVC!
460 let use_dll_storage_attrs
= tcx
.sess
.target
.target
.options
.is_like_msvc
;
463 metadata_llmod
: metadata_llmod
,
464 metadata_llcx
: metadata_llcx
,
465 export_map
: export_map
,
466 exported_symbols
: exported_symbols
,
467 link_meta
: link_meta
,
468 empty_param_env
: tcx
.empty_parameter_environment(),
471 n_glues_created
: Cell
::new(0),
472 n_null_glues
: Cell
::new(0),
473 n_real_glues
: Cell
::new(0),
475 n_inlines
: Cell
::new(0),
476 n_closures
: Cell
::new(0),
477 n_llvm_insns
: Cell
::new(0),
478 llvm_insns
: RefCell
::new(FxHashMap()),
479 fn_stats
: RefCell
::new(Vec
::new()),
481 check_overflow
: check_overflow
,
482 use_dll_storage_attrs
: use_dll_storage_attrs
,
483 translation_items
: RefCell
::new(FxHashSet()),
484 trait_cache
: RefCell
::new(DepTrackingMap
::new(tcx
.dep_graph
.clone())),
485 project_cache
: RefCell
::new(DepTrackingMap
::new(tcx
.dep_graph
.clone())),
489 pub fn type_needs_drop(&self, ty
: Ty
<'tcx
>) -> bool
{
490 self.tcx
.type_needs_drop_given_env(ty
, &self.empty_param_env
)
493 pub fn type_is_sized(&self, ty
: Ty
<'tcx
>) -> bool
{
494 ty
.is_sized(self.tcx
, &self.empty_param_env
, DUMMY_SP
)
497 pub fn metadata_llmod(&self) -> ModuleRef
{
501 pub fn metadata_llcx(&self) -> ContextRef
{
505 pub fn export_map
<'a
>(&'a
self) -> &'a ExportMap
{
509 pub fn exported_symbols
<'a
>(&'a
self) -> &'a NodeSet
{
510 &self.exported_symbols
513 pub fn trait_cache(&self) -> &RefCell
<DepTrackingMap
<TraitSelectionCache
<'tcx
>>> {
517 pub fn project_cache(&self) -> &RefCell
<DepTrackingMap
<ProjectionCache
<'tcx
>>> {
521 pub fn link_meta
<'a
>(&'a
self) -> &'a LinkMeta
{
525 pub fn tcx
<'a
>(&'a
self) -> TyCtxt
<'a
, 'tcx
, 'tcx
> {
529 pub fn sess
<'a
>(&'a
self) -> &'a Session
{
533 pub fn dep_graph
<'a
>(&'a
self) -> &'a DepGraph
{
537 pub fn stats
<'a
>(&'a
self) -> &'a Stats
{
541 pub fn use_dll_storage_attrs(&self) -> bool
{
542 self.use_dll_storage_attrs
545 pub fn translation_items(&self) -> &RefCell
<FxHashSet
<TransItem
<'tcx
>>> {
546 &self.translation_items
549 /// Given the def-id of some item that has no type parameters, make
550 /// a suitable "empty substs" for it.
551 pub fn empty_substs_for_def_id(&self, item_def_id
: DefId
) -> &'tcx Substs
<'tcx
> {
552 Substs
::for_item(self.tcx(), item_def_id
,
553 |_
, _
| self.tcx().mk_region(ty
::ReErased
),
555 bug
!("empty_substs_for_def_id: {:?} has type parameters", item_def_id
)
559 pub fn metadata_symbol_name(&self) -> String
{
560 format
!("rust_metadata_{}_{}",
561 self.link_meta().crate_name
,
562 self.link_meta().crate_hash
)
566 impl<'tcx
> LocalCrateContext
<'tcx
> {
567 fn new
<'a
>(shared
: &SharedCrateContext
<'a
, 'tcx
>,
568 codegen_unit
: CodegenUnit
<'tcx
>,
569 previous_work_product
: Option
<WorkProduct
>,
570 symbol_map
: Rc
<SymbolMap
<'tcx
>>)
571 -> LocalCrateContext
<'tcx
> {
573 // Append ".rs" to LLVM module identifier.
575 // LLVM code generator emits a ".file filename" directive
576 // for ELF backends. Value of the "filename" is set as the
577 // LLVM module identifier. Due to a LLVM MC bug[1], LLVM
578 // crashes if the module identifier is same as other symbols
579 // such as a function name in the module.
580 // 1. http://llvm.org/bugs/show_bug.cgi?id=11479
581 let llmod_id
= format
!("{}.rs", codegen_unit
.name());
583 let (llcx
, llmod
) = create_context_and_module(&shared
.tcx
.sess
,
586 let dbg_cx
= if shared
.tcx
.sess
.opts
.debuginfo
!= NoDebugInfo
{
587 let dctx
= debuginfo
::CrateDebugContext
::new(llmod
);
588 debuginfo
::metadata
::compile_unit_metadata(shared
, &dctx
, shared
.tcx
.sess
);
594 let local_ccx
= LocalCrateContext
{
597 previous_work_product
: previous_work_product
,
598 codegen_unit
: codegen_unit
,
599 needs_unwind_cleanup_cache
: RefCell
::new(FxHashMap()),
600 fn_pointer_shims
: RefCell
::new(FxHashMap()),
601 drop_glues
: RefCell
::new(FxHashMap()),
602 instances
: RefCell
::new(FxHashMap()),
603 vtables
: RefCell
::new(FxHashMap()),
604 const_cstr_cache
: RefCell
::new(FxHashMap()),
605 const_unsized
: RefCell
::new(FxHashMap()),
606 const_globals
: RefCell
::new(FxHashMap()),
607 const_values
: RefCell
::new(FxHashMap()),
608 extern_const_values
: RefCell
::new(DefIdMap()),
609 statics
: RefCell
::new(FxHashMap()),
610 impl_method_cache
: RefCell
::new(FxHashMap()),
611 closure_bare_wrapper_cache
: RefCell
::new(FxHashMap()),
612 statics_to_rauw
: RefCell
::new(Vec
::new()),
613 lltypes
: RefCell
::new(FxHashMap()),
614 llsizingtypes
: RefCell
::new(FxHashMap()),
615 type_hashcodes
: RefCell
::new(FxHashMap()),
616 int_type
: Type
::from_ref(ptr
::null_mut()),
617 opaque_vec_type
: Type
::from_ref(ptr
::null_mut()),
618 str_slice_type
: Type
::from_ref(ptr
::null_mut()),
619 closure_vals
: RefCell
::new(FxHashMap()),
621 eh_personality
: Cell
::new(None
),
622 eh_unwind_resume
: Cell
::new(None
),
623 rust_try_fn
: Cell
::new(None
),
624 intrinsics
: RefCell
::new(FxHashMap()),
625 type_of_depth
: Cell
::new(0),
626 symbol_map
: symbol_map
,
627 local_gen_sym_counter
: Cell
::new(0),
630 let (int_type
, opaque_vec_type
, str_slice_ty
, mut local_ccx
) = {
631 // Do a little dance to create a dummy CrateContext, so we can
632 // create some things in the LLVM module of this codegen unit
633 let mut local_ccxs
= vec
![local_ccx
];
634 let (int_type
, opaque_vec_type
, str_slice_ty
) = {
635 let dummy_ccx
= LocalCrateContext
::dummy_ccx(shared
,
636 local_ccxs
.as_mut_slice());
637 let mut str_slice_ty
= Type
::named_struct(&dummy_ccx
, "str_slice");
638 str_slice_ty
.set_struct_body(&[Type
::i8p(&dummy_ccx
),
639 Type
::int(&dummy_ccx
)],
641 (Type
::int(&dummy_ccx
), Type
::opaque_vec(&dummy_ccx
), str_slice_ty
)
643 (int_type
, opaque_vec_type
, str_slice_ty
, local_ccxs
.pop().unwrap())
646 local_ccx
.int_type
= int_type
;
647 local_ccx
.opaque_vec_type
= opaque_vec_type
;
648 local_ccx
.str_slice_type
= str_slice_ty
;
654 /// Create a dummy `CrateContext` from `self` and the provided
655 /// `SharedCrateContext`. This is somewhat dangerous because `self` may
656 /// not be fully initialized.
658 /// This is used in the `LocalCrateContext` constructor to allow calling
659 /// functions that expect a complete `CrateContext`, even before the local
660 /// portion is fully initialized and attached to the `SharedCrateContext`.
661 fn dummy_ccx
<'a
>(shared
: &'a SharedCrateContext
<'a
, 'tcx
>,
662 local_ccxs
: &'a
[LocalCrateContext
<'tcx
>])
663 -> CrateContext
<'a
, 'tcx
> {
664 assert
!(local_ccxs
.len() == 1);
668 local_ccxs
: local_ccxs
673 impl<'b
, 'tcx
> CrateContext
<'b
, 'tcx
> {
674 pub fn shared(&self) -> &'b SharedCrateContext
<'b
, 'tcx
> {
678 fn local(&self) -> &'b LocalCrateContext
<'tcx
> {
679 &self.local_ccxs
[self.index
]
682 pub fn tcx
<'a
>(&'a
self) -> TyCtxt
<'a
, 'tcx
, 'tcx
> {
686 pub fn sess
<'a
>(&'a
self) -> &'a Session
{
687 &self.shared
.tcx
.sess
690 pub fn get_intrinsic(&self, key
: &str) -> ValueRef
{
691 if let Some(v
) = self.intrinsics().borrow().get(key
).cloned() {
694 match declare_intrinsic(self, key
) {
696 None
=> bug
!("unknown intrinsic '{}'", key
)
700 pub fn llmod(&self) -> ModuleRef
{
704 pub fn llcx(&self) -> ContextRef
{
708 pub fn previous_work_product(&self) -> Option
<&WorkProduct
> {
709 self.local().previous_work_product
.as_ref()
712 pub fn codegen_unit(&self) -> &CodegenUnit
<'tcx
> {
713 &self.local().codegen_unit
716 pub fn td(&self) -> llvm
::TargetDataRef
{
717 unsafe { llvm::LLVMRustGetModuleDataLayout(self.llmod()) }
720 pub fn export_map
<'a
>(&'a
self) -> &'a ExportMap
{
721 &self.shared
.export_map
724 pub fn exported_symbols
<'a
>(&'a
self) -> &'a NodeSet
{
725 &self.shared
.exported_symbols
728 pub fn link_meta
<'a
>(&'a
self) -> &'a LinkMeta
{
729 &self.shared
.link_meta
732 pub fn needs_unwind_cleanup_cache(&self) -> &RefCell
<FxHashMap
<Ty
<'tcx
>, bool
>> {
733 &self.local().needs_unwind_cleanup_cache
736 pub fn fn_pointer_shims(&self) -> &RefCell
<FxHashMap
<Ty
<'tcx
>, ValueRef
>> {
737 &self.local().fn_pointer_shims
740 pub fn drop_glues
<'a
>(&'a
self)
741 -> &'a RefCell
<FxHashMap
<DropGlueKind
<'tcx
>, (ValueRef
, FnType
)>> {
742 &self.local().drop_glues
745 pub fn instances
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<Instance
<'tcx
>, ValueRef
>> {
746 &self.local().instances
749 pub fn vtables
<'a
>(&'a
self)
750 -> &'a RefCell
<FxHashMap
<(ty
::Ty
<'tcx
>,
751 Option
<ty
::PolyExistentialTraitRef
<'tcx
>>), ValueRef
>> {
752 &self.local().vtables
755 pub fn const_cstr_cache
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<InternedString
, ValueRef
>> {
756 &self.local().const_cstr_cache
759 pub fn const_unsized
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<ValueRef
, ValueRef
>> {
760 &self.local().const_unsized
763 pub fn const_globals
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<ValueRef
, ValueRef
>> {
764 &self.local().const_globals
767 pub fn const_values
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<(ast
::NodeId
, &'tcx Substs
<'tcx
>),
769 &self.local().const_values
772 pub fn extern_const_values
<'a
>(&'a
self) -> &'a RefCell
<DefIdMap
<ValueRef
>> {
773 &self.local().extern_const_values
776 pub fn statics
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<ValueRef
, DefId
>> {
777 &self.local().statics
780 pub fn impl_method_cache
<'a
>(&'a
self)
781 -> &'a RefCell
<FxHashMap
<(DefId
, ast
::Name
), DefId
>> {
782 &self.local().impl_method_cache
785 pub fn closure_bare_wrapper_cache
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<ValueRef
, ValueRef
>> {
786 &self.local().closure_bare_wrapper_cache
789 pub fn statics_to_rauw
<'a
>(&'a
self) -> &'a RefCell
<Vec
<(ValueRef
, ValueRef
)>> {
790 &self.local().statics_to_rauw
793 pub fn lltypes
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<Ty
<'tcx
>, Type
>> {
794 &self.local().lltypes
797 pub fn llsizingtypes
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<Ty
<'tcx
>, Type
>> {
798 &self.local().llsizingtypes
801 pub fn type_hashcodes
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<Ty
<'tcx
>, String
>> {
802 &self.local().type_hashcodes
805 pub fn stats
<'a
>(&'a
self) -> &'a Stats
{
809 pub fn int_type(&self) -> Type
{
810 self.local().int_type
813 pub fn opaque_vec_type(&self) -> Type
{
814 self.local().opaque_vec_type
817 pub fn str_slice_type(&self) -> Type
{
818 self.local().str_slice_type
821 pub fn closure_vals
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<Instance
<'tcx
>, ValueRef
>> {
822 &self.local().closure_vals
825 pub fn dbg_cx
<'a
>(&'a
self) -> &'a Option
<debuginfo
::CrateDebugContext
<'tcx
>> {
829 pub fn rust_try_fn
<'a
>(&'a
self) -> &'a Cell
<Option
<ValueRef
>> {
830 &self.local().rust_try_fn
833 fn intrinsics
<'a
>(&'a
self) -> &'a RefCell
<FxHashMap
<&'
static str, ValueRef
>> {
834 &self.local().intrinsics
837 pub fn obj_size_bound(&self) -> u64 {
838 self.tcx().data_layout
.obj_size_bound()
841 pub fn report_overbig_object(&self, obj
: Ty
<'tcx
>) -> ! {
843 &format
!("the type `{:?}` is too big for the current architecture",
847 pub fn enter_type_of(&self, ty
: Ty
<'tcx
>) -> TypeOfDepthLock
<'b
, 'tcx
> {
848 let current_depth
= self.local().type_of_depth
.get();
849 debug
!("enter_type_of({:?}) at depth {:?}", ty
, current_depth
);
850 if current_depth
> self.sess().recursion_limit
.get() {
852 &format
!("overflow representing the type `{}`", ty
))
854 self.local().type_of_depth
.set(current_depth
+ 1);
855 TypeOfDepthLock(self.local())
858 pub fn layout_of(&self, ty
: Ty
<'tcx
>) -> &'tcx ty
::layout
::Layout
{
859 self.tcx().infer_ctxt((), traits
::Reveal
::All
).enter(|infcx
| {
860 ty
.layout(&infcx
).unwrap_or_else(|e
| {
862 ty
::layout
::LayoutError
::SizeOverflow(_
) =>
863 self.sess().fatal(&e
.to_string()),
864 _
=> bug
!("failed to get layout for `{}`: {}", ty
, e
)
870 pub fn check_overflow(&self) -> bool
{
871 self.shared
.check_overflow
874 pub fn use_dll_storage_attrs(&self) -> bool
{
875 self.shared
.use_dll_storage_attrs()
878 pub fn symbol_map(&self) -> &SymbolMap
<'tcx
> {
879 &*self.local().symbol_map
882 pub fn translation_items(&self) -> &RefCell
<FxHashSet
<TransItem
<'tcx
>>> {
883 &self.shared
.translation_items
886 /// Given the def-id of some item that has no type parameters, make
887 /// a suitable "empty substs" for it.
888 pub fn empty_substs_for_def_id(&self, item_def_id
: DefId
) -> &'tcx Substs
<'tcx
> {
889 self.shared().empty_substs_for_def_id(item_def_id
)
892 /// Generate a new symbol name with the given prefix. This symbol name must
893 /// only be used for definitions with `internal` or `private` linkage.
894 pub fn generate_local_symbol_name(&self, prefix
: &str) -> String
{
895 let idx
= self.local().local_gen_sym_counter
.get();
896 self.local().local_gen_sym_counter
.set(idx
+ 1);
897 // Include a '.' character, so there can be no accidental conflicts with
898 // user defined names
899 let mut name
= String
::with_capacity(prefix
.len() + 6);
900 name
.push_str(prefix
);
902 base_n
::push_str(idx
as u64, base_n
::ALPHANUMERIC_ONLY
, &mut name
);
906 pub fn eh_personality(&self) -> ValueRef
{
907 // The exception handling personality function.
909 // If our compilation unit has the `eh_personality` lang item somewhere
910 // within it, then we just need to translate that. Otherwise, we're
911 // building an rlib which will depend on some upstream implementation of
912 // this function, so we just codegen a generic reference to it. We don't
913 // specify any of the types for the function, we just make it a symbol
914 // that LLVM can later use.
916 // Note that MSVC is a little special here in that we don't use the
917 // `eh_personality` lang item at all. Currently LLVM has support for
918 // both Dwarf and SEH unwind mechanisms for MSVC targets and uses the
919 // *name of the personality function* to decide what kind of unwind side
920 // tables/landing pads to emit. It looks like Dwarf is used by default,
921 // injecting a dependency on the `_Unwind_Resume` symbol for resuming
922 // an "exception", but for MSVC we want to force SEH. This means that we
923 // can't actually have the personality function be our standard
924 // `rust_eh_personality` function, but rather we wired it up to the
925 // CRT's custom personality function, which forces LLVM to consider
926 // landing pads as "landing pads for SEH".
927 if let Some(llpersonality
) = self.local().eh_personality
.get() {
930 let tcx
= self.tcx();
931 let llfn
= match tcx
.lang_items
.eh_personality() {
932 Some(def_id
) if !base
::wants_msvc_seh(self.sess()) => {
933 Callee
::def(self, def_id
, tcx
.intern_substs(&[])).reify(self)
936 let name
= if base
::wants_msvc_seh(self.sess()) {
939 "rust_eh_personality"
941 let fty
= Type
::variadic_func(&[], &Type
::i32(self));
942 declare
::declare_cfn(self, name
, fty
)
945 self.local().eh_personality
.set(Some(llfn
));
949 // Returns a ValueRef of the "eh_unwind_resume" lang item if one is defined,
950 // otherwise declares it as an external function.
951 pub fn eh_unwind_resume(&self) -> ValueRef
{
953 let unwresume
= &self.local().eh_unwind_resume
;
954 if let Some(llfn
) = unwresume
.get() {
958 let tcx
= self.tcx();
959 assert
!(self.sess().target
.target
.options
.custom_unwind_resume
);
960 if let Some(def_id
) = tcx
.lang_items
.eh_unwind_resume() {
961 let llfn
= Callee
::def(self, def_id
, tcx
.intern_substs(&[])).reify(self);
962 unwresume
.set(Some(llfn
));
966 let ty
= tcx
.mk_fn_ptr(ty
::Binder(tcx
.mk_fn_sig(
967 iter
::once(tcx
.mk_mut_ptr(tcx
.types
.u8)),
970 hir
::Unsafety
::Unsafe
,
974 let llfn
= declare
::declare_fn(self, "rust_eh_unwind_resume", ty
);
975 attributes
::unwind(llfn
, true);
976 unwresume
.set(Some(llfn
));
981 pub struct TypeOfDepthLock
<'a
, 'tcx
: 'a
>(&'a LocalCrateContext
<'tcx
>);
983 impl<'a
, 'tcx
> Drop
for TypeOfDepthLock
<'a
, 'tcx
> {
985 self.0.type_of_depth
.set(self.0.type_of_depth
.get() - 1);
989 /// Declare any llvm intrinsics that you might need
990 fn declare_intrinsic(ccx
: &CrateContext
, key
: &str) -> Option
<ValueRef
> {
992 ($name
:expr
, fn() -> $ret
:expr
) => (
994 let f
= declare
::declare_cfn(ccx
, $name
, Type
::func(&[], &$ret
));
995 llvm
::SetUnnamedAddr(f
, false);
996 ccx
.intrinsics().borrow_mut().insert($name
, f
.clone());
1000 ($name
:expr
, fn(...) -> $ret
:expr
) => (
1002 let f
= declare
::declare_cfn(ccx
, $name
, Type
::variadic_func(&[], &$ret
));
1003 llvm
::SetUnnamedAddr(f
, false);
1004 ccx
.intrinsics().borrow_mut().insert($name
, f
.clone());
1008 ($name
:expr
, fn($
($arg
:expr
),*) -> $ret
:expr
) => (
1010 let f
= declare
::declare_cfn(ccx
, $name
, Type
::func(&[$
($arg
),*], &$ret
));
1011 llvm
::SetUnnamedAddr(f
, false);
1012 ccx
.intrinsics().borrow_mut().insert($name
, f
.clone());
1017 macro_rules
! mk_struct
{
1018 ($
($field_ty
:expr
),*) => (Type
::struct_(ccx
, &[$
($field_ty
),*], false))
1021 let i8p
= Type
::i8p(ccx
);
1022 let void
= Type
::void(ccx
);
1023 let i1
= Type
::i1(ccx
);
1024 let t_i8
= Type
::i8(ccx
);
1025 let t_i16
= Type
::i16(ccx
);
1026 let t_i32
= Type
::i32(ccx
);
1027 let t_i64
= Type
::i64(ccx
);
1028 let t_i128
= Type
::i128(ccx
);
1029 let t_f32
= Type
::f32(ccx
);
1030 let t_f64
= Type
::f64(ccx
);
1032 ifn
!("llvm.memcpy.p0i8.p0i8.i16", fn(i8p
, i8p
, t_i16
, t_i32
, i1
) -> void
);
1033 ifn
!("llvm.memcpy.p0i8.p0i8.i32", fn(i8p
, i8p
, t_i32
, t_i32
, i1
) -> void
);
1034 ifn
!("llvm.memcpy.p0i8.p0i8.i64", fn(i8p
, i8p
, t_i64
, t_i32
, i1
) -> void
);
1035 ifn
!("llvm.memmove.p0i8.p0i8.i16", fn(i8p
, i8p
, t_i16
, t_i32
, i1
) -> void
);
1036 ifn
!("llvm.memmove.p0i8.p0i8.i32", fn(i8p
, i8p
, t_i32
, t_i32
, i1
) -> void
);
1037 ifn
!("llvm.memmove.p0i8.p0i8.i64", fn(i8p
, i8p
, t_i64
, t_i32
, i1
) -> void
);
1038 ifn
!("llvm.memset.p0i8.i16", fn(i8p
, t_i8
, t_i16
, t_i32
, i1
) -> void
);
1039 ifn
!("llvm.memset.p0i8.i32", fn(i8p
, t_i8
, t_i32
, t_i32
, i1
) -> void
);
1040 ifn
!("llvm.memset.p0i8.i64", fn(i8p
, t_i8
, t_i64
, t_i32
, i1
) -> void
);
1042 ifn
!("llvm.trap", fn() -> void
);
1043 ifn
!("llvm.debugtrap", fn() -> void
);
1044 ifn
!("llvm.frameaddress", fn(t_i32
) -> i8p
);
1046 ifn
!("llvm.powi.f32", fn(t_f32
, t_i32
) -> t_f32
);
1047 ifn
!("llvm.powi.f64", fn(t_f64
, t_i32
) -> t_f64
);
1048 ifn
!("llvm.pow.f32", fn(t_f32
, t_f32
) -> t_f32
);
1049 ifn
!("llvm.pow.f64", fn(t_f64
, t_f64
) -> t_f64
);
1051 ifn
!("llvm.sqrt.f32", fn(t_f32
) -> t_f32
);
1052 ifn
!("llvm.sqrt.f64", fn(t_f64
) -> t_f64
);
1053 ifn
!("llvm.sin.f32", fn(t_f32
) -> t_f32
);
1054 ifn
!("llvm.sin.f64", fn(t_f64
) -> t_f64
);
1055 ifn
!("llvm.cos.f32", fn(t_f32
) -> t_f32
);
1056 ifn
!("llvm.cos.f64", fn(t_f64
) -> t_f64
);
1057 ifn
!("llvm.exp.f32", fn(t_f32
) -> t_f32
);
1058 ifn
!("llvm.exp.f64", fn(t_f64
) -> t_f64
);
1059 ifn
!("llvm.exp2.f32", fn(t_f32
) -> t_f32
);
1060 ifn
!("llvm.exp2.f64", fn(t_f64
) -> t_f64
);
1061 ifn
!("llvm.log.f32", fn(t_f32
) -> t_f32
);
1062 ifn
!("llvm.log.f64", fn(t_f64
) -> t_f64
);
1063 ifn
!("llvm.log10.f32", fn(t_f32
) -> t_f32
);
1064 ifn
!("llvm.log10.f64", fn(t_f64
) -> t_f64
);
1065 ifn
!("llvm.log2.f32", fn(t_f32
) -> t_f32
);
1066 ifn
!("llvm.log2.f64", fn(t_f64
) -> t_f64
);
1068 ifn
!("llvm.fma.f32", fn(t_f32
, t_f32
, t_f32
) -> t_f32
);
1069 ifn
!("llvm.fma.f64", fn(t_f64
, t_f64
, t_f64
) -> t_f64
);
1071 ifn
!("llvm.fabs.f32", fn(t_f32
) -> t_f32
);
1072 ifn
!("llvm.fabs.f64", fn(t_f64
) -> t_f64
);
1074 ifn
!("llvm.floor.f32", fn(t_f32
) -> t_f32
);
1075 ifn
!("llvm.floor.f64", fn(t_f64
) -> t_f64
);
1076 ifn
!("llvm.ceil.f32", fn(t_f32
) -> t_f32
);
1077 ifn
!("llvm.ceil.f64", fn(t_f64
) -> t_f64
);
1078 ifn
!("llvm.trunc.f32", fn(t_f32
) -> t_f32
);
1079 ifn
!("llvm.trunc.f64", fn(t_f64
) -> t_f64
);
1081 ifn
!("llvm.copysign.f32", fn(t_f32
, t_f32
) -> t_f32
);
1082 ifn
!("llvm.copysign.f64", fn(t_f64
, t_f64
) -> t_f64
);
1083 ifn
!("llvm.round.f32", fn(t_f32
) -> t_f32
);
1084 ifn
!("llvm.round.f64", fn(t_f64
) -> t_f64
);
1086 ifn
!("llvm.rint.f32", fn(t_f32
) -> t_f32
);
1087 ifn
!("llvm.rint.f64", fn(t_f64
) -> t_f64
);
1088 ifn
!("llvm.nearbyint.f32", fn(t_f32
) -> t_f32
);
1089 ifn
!("llvm.nearbyint.f64", fn(t_f64
) -> t_f64
);
1091 ifn
!("llvm.ctpop.i8", fn(t_i8
) -> t_i8
);
1092 ifn
!("llvm.ctpop.i16", fn(t_i16
) -> t_i16
);
1093 ifn
!("llvm.ctpop.i32", fn(t_i32
) -> t_i32
);
1094 ifn
!("llvm.ctpop.i64", fn(t_i64
) -> t_i64
);
1095 ifn
!("llvm.ctpop.i128", fn(t_i128
) -> t_i128
);
1097 ifn
!("llvm.ctlz.i8", fn(t_i8
, i1
) -> t_i8
);
1098 ifn
!("llvm.ctlz.i16", fn(t_i16
, i1
) -> t_i16
);
1099 ifn
!("llvm.ctlz.i32", fn(t_i32
, i1
) -> t_i32
);
1100 ifn
!("llvm.ctlz.i64", fn(t_i64
, i1
) -> t_i64
);
1101 ifn
!("llvm.ctlz.i128", fn(t_i128
, i1
) -> t_i128
);
1103 ifn
!("llvm.cttz.i8", fn(t_i8
, i1
) -> t_i8
);
1104 ifn
!("llvm.cttz.i16", fn(t_i16
, i1
) -> t_i16
);
1105 ifn
!("llvm.cttz.i32", fn(t_i32
, i1
) -> t_i32
);
1106 ifn
!("llvm.cttz.i64", fn(t_i64
, i1
) -> t_i64
);
1107 ifn
!("llvm.cttz.i128", fn(t_i128
, i1
) -> t_i128
);
1109 ifn
!("llvm.bswap.i16", fn(t_i16
) -> t_i16
);
1110 ifn
!("llvm.bswap.i32", fn(t_i32
) -> t_i32
);
1111 ifn
!("llvm.bswap.i64", fn(t_i64
) -> t_i64
);
1112 ifn
!("llvm.bswap.i128", fn(t_i128
) -> t_i128
);
1114 ifn
!("llvm.sadd.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
1115 ifn
!("llvm.sadd.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
1116 ifn
!("llvm.sadd.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
1117 ifn
!("llvm.sadd.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
1118 ifn
!("llvm.sadd.with.overflow.i128", fn(t_i128
, t_i128
) -> mk_struct
!{t_i128, i1}
);
1120 ifn
!("llvm.uadd.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
1121 ifn
!("llvm.uadd.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
1122 ifn
!("llvm.uadd.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
1123 ifn
!("llvm.uadd.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
1124 ifn
!("llvm.uadd.with.overflow.i128", fn(t_i128
, t_i128
) -> mk_struct
!{t_i128, i1}
);
1126 ifn
!("llvm.ssub.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
1127 ifn
!("llvm.ssub.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
1128 ifn
!("llvm.ssub.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
1129 ifn
!("llvm.ssub.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
1130 ifn
!("llvm.ssub.with.overflow.i128", fn(t_i128
, t_i128
) -> mk_struct
!{t_i128, i1}
);
1132 ifn
!("llvm.usub.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
1133 ifn
!("llvm.usub.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
1134 ifn
!("llvm.usub.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
1135 ifn
!("llvm.usub.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
1136 ifn
!("llvm.usub.with.overflow.i128", fn(t_i128
, t_i128
) -> mk_struct
!{t_i128, i1}
);
1138 ifn
!("llvm.smul.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
1139 ifn
!("llvm.smul.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
1140 ifn
!("llvm.smul.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
1141 ifn
!("llvm.smul.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
1142 ifn
!("llvm.smul.with.overflow.i128", fn(t_i128
, t_i128
) -> mk_struct
!{t_i128, i1}
);
1144 ifn
!("llvm.umul.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
1145 ifn
!("llvm.umul.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
1146 ifn
!("llvm.umul.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
1147 ifn
!("llvm.umul.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
1148 ifn
!("llvm.umul.with.overflow.i128", fn(t_i128
, t_i128
) -> mk_struct
!{t_i128, i1}
);
1150 ifn
!("llvm.lifetime.start", fn(t_i64
,i8p
) -> void
);
1151 ifn
!("llvm.lifetime.end", fn(t_i64
, i8p
) -> void
);
1153 ifn
!("llvm.expect.i1", fn(i1
, i1
) -> i1
);
1154 ifn
!("llvm.eh.typeid.for", fn(i8p
) -> t_i32
);
1155 ifn
!("llvm.localescape", fn(...) -> void
);
1156 ifn
!("llvm.localrecover", fn(i8p
, i8p
, t_i32
) -> i8p
);
1157 ifn
!("llvm.x86.seh.recoverfp", fn(i8p
, i8p
) -> i8p
);
1159 ifn
!("llvm.assume", fn(i1
) -> void
);
1161 if ccx
.sess().opts
.debuginfo
!= NoDebugInfo
{
1162 ifn
!("llvm.dbg.declare", fn(Type
::metadata(ccx
), Type
::metadata(ccx
)) -> void
);
1163 ifn
!("llvm.dbg.value", fn(Type
::metadata(ccx
), t_i64
, Type
::metadata(ccx
)) -> void
);