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, BuilderRef}
;
14 use llvm
::mk_target_data
;
15 use metadata
::common
::LinkMeta
;
16 use middle
::def
::ExportMap
;
20 use trans
::builder
::Builder
;
21 use trans
::common
::{ExternMap,BuilderRef_res}
;
24 use trans
::glue
::DropGlueKind
;
25 use trans
::monomorphize
::MonoId
;
26 use trans
::type_
::{Type, TypeNames}
;
27 use middle
::subst
::Substs
;
28 use middle
::ty
::{self, Ty}
;
29 use session
::config
::NoDebugInfo
;
31 use util
::ppaux
::Repr
;
32 use util
::sha2
::Sha256
;
33 use util
::nodemap
::{NodeMap, NodeSet, DefIdMap, FnvHashMap, FnvHashSet}
;
35 use std
::ffi
::CString
;
36 use std
::cell
::{Cell, RefCell}
;
40 use syntax
::parse
::token
::InternedString
;
43 pub n_glues_created
: Cell
<usize>,
44 pub n_null_glues
: Cell
<usize>,
45 pub n_real_glues
: Cell
<usize>,
46 pub n_fns
: Cell
<usize>,
47 pub n_monos
: Cell
<usize>,
48 pub n_inlines
: Cell
<usize>,
49 pub n_closures
: Cell
<usize>,
50 pub n_llvm_insns
: Cell
<usize>,
51 pub llvm_insns
: RefCell
<FnvHashMap
<String
, usize>>,
52 // (ident, llvm-instructions)
53 pub fn_stats
: RefCell
<Vec
<(String
, usize)> >,
56 /// The shared portion of a `CrateContext`. There is one `SharedCrateContext`
57 /// per crate. The data here is shared between all compilation units of the
58 /// crate, so it must not contain references to any LLVM data structures
59 /// (aside from metadata-related ones).
60 pub struct SharedCrateContext
<'tcx
> {
61 local_ccxs
: Vec
<LocalCrateContext
<'tcx
>>,
63 metadata_llmod
: ModuleRef
,
64 metadata_llcx
: ContextRef
,
66 export_map
: ExportMap
,
68 item_symbols
: RefCell
<NodeMap
<String
>>,
70 symbol_hasher
: RefCell
<Sha256
>,
74 check_drop_flag_for_sanity
: bool
,
76 available_monomorphizations
: RefCell
<FnvHashSet
<String
>>,
77 available_drop_glues
: RefCell
<FnvHashMap
<DropGlueKind
<'tcx
>, String
>>,
80 /// The local portion of a `CrateContext`. There is one `LocalCrateContext`
81 /// per compilation unit. Each one has its own LLVM `ContextRef` so that
82 /// several compilation units may be optimized in parallel. All other LLVM
83 /// data structures in the `LocalCrateContext` are tied to that `ContextRef`.
84 pub struct LocalCrateContext
<'tcx
> {
89 externs
: RefCell
<ExternMap
>,
90 item_vals
: RefCell
<NodeMap
<ValueRef
>>,
91 needs_unwind_cleanup_cache
: RefCell
<FnvHashMap
<Ty
<'tcx
>, bool
>>,
92 fn_pointer_shims
: RefCell
<FnvHashMap
<Ty
<'tcx
>, ValueRef
>>,
93 drop_glues
: RefCell
<FnvHashMap
<DropGlueKind
<'tcx
>, ValueRef
>>,
94 /// Track mapping of external ids to local items imported for inlining
95 external
: RefCell
<DefIdMap
<Option
<ast
::NodeId
>>>,
96 /// Backwards version of the `external` map (inlined items to where they
98 external_srcs
: RefCell
<NodeMap
<ast
::DefId
>>,
99 /// Cache instances of monomorphized functions
100 monomorphized
: RefCell
<FnvHashMap
<MonoId
<'tcx
>, ValueRef
>>,
101 monomorphizing
: RefCell
<DefIdMap
<usize>>,
102 /// Cache generated vtables
103 vtables
: RefCell
<FnvHashMap
<ty
::PolyTraitRef
<'tcx
>, ValueRef
>>,
104 /// Cache of constant strings,
105 const_cstr_cache
: RefCell
<FnvHashMap
<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
<FnvHashMap
<ValueRef
, ValueRef
>>,
117 /// Cache of emitted const globals (value -> global)
118 const_globals
: RefCell
<FnvHashMap
<ValueRef
, ValueRef
>>,
120 /// Cache of emitted const values
121 const_values
: RefCell
<FnvHashMap
<(ast
::NodeId
, &'tcx Substs
<'tcx
>), ValueRef
>>,
123 /// Cache of emitted static values
124 static_values
: RefCell
<NodeMap
<ValueRef
>>,
126 /// Cache of external const values
127 extern_const_values
: RefCell
<DefIdMap
<ValueRef
>>,
129 impl_method_cache
: RefCell
<FnvHashMap
<(ast
::DefId
, ast
::Name
), ast
::DefId
>>,
131 /// Cache of closure wrappers for bare fn's.
132 closure_bare_wrapper_cache
: RefCell
<FnvHashMap
<ValueRef
, ValueRef
>>,
134 lltypes
: RefCell
<FnvHashMap
<Ty
<'tcx
>, Type
>>,
135 llsizingtypes
: RefCell
<FnvHashMap
<Ty
<'tcx
>, Type
>>,
136 adt_reprs
: RefCell
<FnvHashMap
<Ty
<'tcx
>, Rc
<adt
::Repr
<'tcx
>>>>,
137 type_hashcodes
: RefCell
<FnvHashMap
<Ty
<'tcx
>, String
>>,
139 opaque_vec_type
: Type
,
140 builder
: BuilderRef_res
,
142 /// Holds the LLVM values for closure IDs.
143 closure_vals
: RefCell
<FnvHashMap
<MonoId
<'tcx
>, ValueRef
>>,
145 dbg_cx
: Option
<debuginfo
::CrateDebugContext
<'tcx
>>,
147 eh_personality
: RefCell
<Option
<ValueRef
>>,
149 intrinsics
: RefCell
<FnvHashMap
<&'
static str, ValueRef
>>,
151 /// Number of LLVM instructions translated into this `LocalCrateContext`.
152 /// This is used to perform some basic load-balancing to keep all LLVM
153 /// contexts around the same size.
154 n_llvm_insns
: Cell
<usize>,
156 trait_cache
: RefCell
<FnvHashMap
<ty
::PolyTraitRef
<'tcx
>,
157 traits
::Vtable
<'tcx
, ()>>>,
160 pub struct CrateContext
<'a
, 'tcx
: 'a
> {
161 shared
: &'a SharedCrateContext
<'tcx
>,
162 local
: &'a LocalCrateContext
<'tcx
>,
163 /// The index of `local` in `shared.local_ccxs`. This is used in
164 /// `maybe_iter(true)` to identify the original `LocalCrateContext`.
168 pub struct CrateContextIterator
<'a
, 'tcx
: 'a
> {
169 shared
: &'a SharedCrateContext
<'tcx
>,
173 impl<'a
, 'tcx
> Iterator
for CrateContextIterator
<'a
,'tcx
> {
174 type Item
= CrateContext
<'a
, 'tcx
>;
176 fn next(&mut self) -> Option
<CrateContext
<'a
, 'tcx
>> {
177 if self.index
>= self.shared
.local_ccxs
.len() {
181 let index
= self.index
;
186 local
: &self.shared
.local_ccxs
[index
],
192 /// The iterator produced by `CrateContext::maybe_iter`.
193 pub struct CrateContextMaybeIterator
<'a
, 'tcx
: 'a
> {
194 shared
: &'a SharedCrateContext
<'tcx
>,
200 impl<'a
, 'tcx
> Iterator
for CrateContextMaybeIterator
<'a
, 'tcx
> {
201 type Item
= (CrateContext
<'a
, 'tcx
>, bool
);
203 fn next(&mut self) -> Option
<(CrateContext
<'a
, 'tcx
>, bool
)> {
204 if self.index
>= self.shared
.local_ccxs
.len() {
208 let index
= self.index
;
211 self.index
= self.shared
.local_ccxs
.len();
214 let ccx
= CrateContext
{
216 local
: &self.shared
.local_ccxs
[index
],
219 Some((ccx
, index
== self.origin
))
224 unsafe fn create_context_and_module(sess
: &Session
, mod_name
: &str) -> (ContextRef
, ModuleRef
) {
225 let llcx
= llvm
::LLVMContextCreate();
226 let mod_name
= CString
::new(mod_name
).unwrap();
227 let llmod
= llvm
::LLVMModuleCreateWithNameInContext(mod_name
.as_ptr(), llcx
);
229 let data_layout
= sess
.target
.target
.data_layout
.as_bytes();
230 let data_layout
= CString
::new(data_layout
).unwrap();
231 llvm
::LLVMSetDataLayout(llmod
, data_layout
.as_ptr());
233 let llvm_target
= sess
.target
.target
.llvm_target
.as_bytes();
234 let llvm_target
= CString
::new(llvm_target
).unwrap();
235 llvm
::LLVMRustSetNormalizedTarget(llmod
, llvm_target
.as_ptr());
239 impl<'tcx
> SharedCrateContext
<'tcx
> {
240 pub fn new(crate_name
: &str,
243 export_map
: ExportMap
,
244 symbol_hasher
: Sha256
,
247 check_overflow
: bool
,
248 check_drop_flag_for_sanity
: bool
)
249 -> SharedCrateContext
<'tcx
> {
250 let (metadata_llcx
, metadata_llmod
) = unsafe {
251 create_context_and_module(&tcx
.sess
, "metadata")
254 let mut shared_ccx
= SharedCrateContext
{
255 local_ccxs
: Vec
::with_capacity(local_count
),
256 metadata_llmod
: metadata_llmod
,
257 metadata_llcx
: metadata_llcx
,
258 export_map
: export_map
,
259 reachable
: reachable
,
260 item_symbols
: RefCell
::new(NodeMap()),
261 link_meta
: link_meta
,
262 symbol_hasher
: RefCell
::new(symbol_hasher
),
265 n_glues_created
: Cell
::new(0),
266 n_null_glues
: Cell
::new(0),
267 n_real_glues
: Cell
::new(0),
269 n_monos
: Cell
::new(0),
270 n_inlines
: Cell
::new(0),
271 n_closures
: Cell
::new(0),
272 n_llvm_insns
: Cell
::new(0),
273 llvm_insns
: RefCell
::new(FnvHashMap()),
274 fn_stats
: RefCell
::new(Vec
::new()),
276 check_overflow
: check_overflow
,
277 check_drop_flag_for_sanity
: check_drop_flag_for_sanity
,
278 available_monomorphizations
: RefCell
::new(FnvHashSet()),
279 available_drop_glues
: RefCell
::new(FnvHashMap()),
282 for i
in 0..local_count
{
283 // Append ".rs" to crate name as LLVM module identifier.
285 // LLVM code generator emits a ".file filename" directive
286 // for ELF backends. Value of the "filename" is set as the
287 // LLVM module identifier. Due to a LLVM MC bug[1], LLVM
288 // crashes if the module identifier is same as other symbols
289 // such as a function name in the module.
290 // 1. http://llvm.org/bugs/show_bug.cgi?id=11479
291 let llmod_id
= format
!("{}.{}.rs", crate_name
, i
);
292 let local_ccx
= LocalCrateContext
::new(&shared_ccx
, &llmod_id
[..]);
293 shared_ccx
.local_ccxs
.push(local_ccx
);
299 pub fn iter
<'a
>(&'a
self) -> CrateContextIterator
<'a
, 'tcx
> {
300 CrateContextIterator
{
306 pub fn get_ccx
<'a
>(&'a
self, index
: usize) -> CrateContext
<'a
, 'tcx
> {
309 local
: &self.local_ccxs
[index
],
314 fn get_smallest_ccx
<'a
>(&'a
self) -> CrateContext
<'a
, 'tcx
> {
315 let (local_ccx
, index
) =
318 .zip(0..self.local_ccxs
.len())
319 .min_by(|&(local_ccx
, _idx
)| local_ccx
.n_llvm_insns
.get())
329 pub fn metadata_llmod(&self) -> ModuleRef
{
333 pub fn metadata_llcx(&self) -> ContextRef
{
337 pub fn export_map
<'a
>(&'a
self) -> &'a ExportMap
{
341 pub fn reachable
<'a
>(&'a
self) -> &'a NodeSet
{
345 pub fn item_symbols
<'a
>(&'a
self) -> &'a RefCell
<NodeMap
<String
>> {
349 pub fn link_meta
<'a
>(&'a
self) -> &'a LinkMeta
{
353 pub fn tcx
<'a
>(&'a
self) -> &'a ty
::ctxt
<'tcx
> {
357 pub fn take_tcx(self) -> ty
::ctxt
<'tcx
> {
361 pub fn sess
<'a
>(&'a
self) -> &'a Session
{
365 pub fn stats
<'a
>(&'a
self) -> &'a Stats
{
370 impl<'tcx
> LocalCrateContext
<'tcx
> {
371 fn new(shared
: &SharedCrateContext
<'tcx
>,
373 -> LocalCrateContext
<'tcx
> {
375 let (llcx
, llmod
) = create_context_and_module(&shared
.tcx
.sess
, name
);
377 let td
= mk_target_data(&shared
.tcx
384 let dbg_cx
= if shared
.tcx
.sess
.opts
.debuginfo
!= NoDebugInfo
{
385 Some(debuginfo
::CrateDebugContext
::new(llmod
))
390 let mut local_ccx
= LocalCrateContext
{
394 tn
: TypeNames
::new(),
395 externs
: RefCell
::new(FnvHashMap()),
396 item_vals
: RefCell
::new(NodeMap()),
397 needs_unwind_cleanup_cache
: RefCell
::new(FnvHashMap()),
398 fn_pointer_shims
: RefCell
::new(FnvHashMap()),
399 drop_glues
: RefCell
::new(FnvHashMap()),
400 external
: RefCell
::new(DefIdMap()),
401 external_srcs
: RefCell
::new(NodeMap()),
402 monomorphized
: RefCell
::new(FnvHashMap()),
403 monomorphizing
: RefCell
::new(DefIdMap()),
404 vtables
: RefCell
::new(FnvHashMap()),
405 const_cstr_cache
: RefCell
::new(FnvHashMap()),
406 const_unsized
: RefCell
::new(FnvHashMap()),
407 const_globals
: RefCell
::new(FnvHashMap()),
408 const_values
: RefCell
::new(FnvHashMap()),
409 static_values
: RefCell
::new(NodeMap()),
410 extern_const_values
: RefCell
::new(DefIdMap()),
411 impl_method_cache
: RefCell
::new(FnvHashMap()),
412 closure_bare_wrapper_cache
: RefCell
::new(FnvHashMap()),
413 lltypes
: RefCell
::new(FnvHashMap()),
414 llsizingtypes
: RefCell
::new(FnvHashMap()),
415 adt_reprs
: RefCell
::new(FnvHashMap()),
416 type_hashcodes
: RefCell
::new(FnvHashMap()),
417 int_type
: Type
::from_ref(ptr
::null_mut()),
418 opaque_vec_type
: Type
::from_ref(ptr
::null_mut()),
419 builder
: BuilderRef_res(llvm
::LLVMCreateBuilderInContext(llcx
)),
420 closure_vals
: RefCell
::new(FnvHashMap()),
422 eh_personality
: RefCell
::new(None
),
423 intrinsics
: RefCell
::new(FnvHashMap()),
424 n_llvm_insns
: Cell
::new(0),
425 trait_cache
: RefCell
::new(FnvHashMap()),
428 local_ccx
.int_type
= Type
::int(&local_ccx
.dummy_ccx(shared
));
429 local_ccx
.opaque_vec_type
= Type
::opaque_vec(&local_ccx
.dummy_ccx(shared
));
431 // Done mutating local_ccx directly. (The rest of the
432 // initialization goes through RefCell.)
434 let ccx
= local_ccx
.dummy_ccx(shared
);
436 let mut str_slice_ty
= Type
::named_struct(&ccx
, "str_slice");
437 str_slice_ty
.set_struct_body(&[Type
::i8p(&ccx
), ccx
.int_type()], false);
438 ccx
.tn().associate_type("str_slice", &str_slice_ty
);
440 if ccx
.sess().count_llvm_insns() {
441 base
::init_insn_ctxt()
449 /// Create a dummy `CrateContext` from `self` and the provided
450 /// `SharedCrateContext`. This is somewhat dangerous because `self` may
451 /// not actually be an element of `shared.local_ccxs`, which can cause some
452 /// operations to panic unexpectedly.
454 /// This is used in the `LocalCrateContext` constructor to allow calling
455 /// functions that expect a complete `CrateContext`, even before the local
456 /// portion is fully initialized and attached to the `SharedCrateContext`.
457 fn dummy_ccx
<'a
>(&'a
self, shared
: &'a SharedCrateContext
<'tcx
>)
458 -> CrateContext
<'a
, 'tcx
> {
467 impl<'b
, 'tcx
> CrateContext
<'b
, 'tcx
> {
468 pub fn shared(&self) -> &'b SharedCrateContext
<'tcx
> {
472 pub fn local(&self) -> &'b LocalCrateContext
<'tcx
> {
477 /// Get a (possibly) different `CrateContext` from the same
478 /// `SharedCrateContext`.
479 pub fn rotate(&self) -> CrateContext
<'b
, 'tcx
> {
480 self.shared
.get_smallest_ccx()
483 /// Either iterate over only `self`, or iterate over all `CrateContext`s in
484 /// the `SharedCrateContext`. The iterator produces `(ccx, is_origin)`
485 /// pairs, where `is_origin` is `true` if `ccx` is `self` and `false`
486 /// otherwise. This method is useful for avoiding code duplication in
487 /// cases where it may or may not be necessary to translate code into every
489 pub fn maybe_iter(&self, iter_all
: bool
) -> CrateContextMaybeIterator
<'b
, 'tcx
> {
490 CrateContextMaybeIterator
{
492 index
: if iter_all { 0 }
else { self.index }
,
499 pub fn tcx
<'a
>(&'a
self) -> &'a ty
::ctxt
<'tcx
> {
503 pub fn sess
<'a
>(&'a
self) -> &'a Session
{
504 &self.shared
.tcx
.sess
507 pub fn builder
<'a
>(&'a
self) -> Builder
<'a
, 'tcx
> {
511 pub fn raw_builder
<'a
>(&'a
self) -> BuilderRef
{
515 pub fn get_intrinsic(&self, key
: & &'
static str) -> ValueRef
{
516 if let Some(v
) = self.intrinsics().borrow().get(key
).cloned() {
519 match declare_intrinsic(self, key
) {
525 pub fn is_split_stack_supported(&self) -> bool
{
526 self.sess().target
.target
.options
.morestack
530 pub fn llmod(&self) -> ModuleRef
{
534 pub fn llcx(&self) -> ContextRef
{
538 pub fn td
<'a
>(&'a
self) -> &'a TargetData
{
542 pub fn tn
<'a
>(&'a
self) -> &'a TypeNames
{
546 pub fn externs
<'a
>(&'a
self) -> &'a RefCell
<ExternMap
> {
550 pub fn item_vals
<'a
>(&'a
self) -> &'a RefCell
<NodeMap
<ValueRef
>> {
551 &self.local
.item_vals
554 pub fn export_map
<'a
>(&'a
self) -> &'a ExportMap
{
555 &self.shared
.export_map
558 pub fn reachable
<'a
>(&'a
self) -> &'a NodeSet
{
559 &self.shared
.reachable
562 pub fn item_symbols
<'a
>(&'a
self) -> &'a RefCell
<NodeMap
<String
>> {
563 &self.shared
.item_symbols
566 pub fn link_meta
<'a
>(&'a
self) -> &'a LinkMeta
{
567 &self.shared
.link_meta
570 pub fn needs_unwind_cleanup_cache(&self) -> &RefCell
<FnvHashMap
<Ty
<'tcx
>, bool
>> {
571 &self.local
.needs_unwind_cleanup_cache
574 pub fn fn_pointer_shims(&self) -> &RefCell
<FnvHashMap
<Ty
<'tcx
>, ValueRef
>> {
575 &self.local
.fn_pointer_shims
578 pub fn drop_glues
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<DropGlueKind
<'tcx
>, ValueRef
>> {
579 &self.local
.drop_glues
582 pub fn external
<'a
>(&'a
self) -> &'a RefCell
<DefIdMap
<Option
<ast
::NodeId
>>> {
586 pub fn external_srcs
<'a
>(&'a
self) -> &'a RefCell
<NodeMap
<ast
::DefId
>> {
587 &self.local
.external_srcs
590 pub fn monomorphized
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<MonoId
<'tcx
>, ValueRef
>> {
591 &self.local
.monomorphized
594 pub fn monomorphizing
<'a
>(&'a
self) -> &'a RefCell
<DefIdMap
<usize>> {
595 &self.local
.monomorphizing
598 pub fn vtables
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<ty
::PolyTraitRef
<'tcx
>, ValueRef
>> {
602 pub fn const_cstr_cache
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<InternedString
, ValueRef
>> {
603 &self.local
.const_cstr_cache
606 pub fn const_unsized
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<ValueRef
, ValueRef
>> {
607 &self.local
.const_unsized
610 pub fn const_globals
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<ValueRef
, ValueRef
>> {
611 &self.local
.const_globals
614 pub fn const_values
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<(ast
::NodeId
, &'tcx Substs
<'tcx
>),
616 &self.local
.const_values
619 pub fn static_values
<'a
>(&'a
self) -> &'a RefCell
<NodeMap
<ValueRef
>> {
620 &self.local
.static_values
623 pub fn extern_const_values
<'a
>(&'a
self) -> &'a RefCell
<DefIdMap
<ValueRef
>> {
624 &self.local
.extern_const_values
627 pub fn impl_method_cache
<'a
>(&'a
self)
628 -> &'a RefCell
<FnvHashMap
<(ast
::DefId
, ast
::Name
), ast
::DefId
>> {
629 &self.local
.impl_method_cache
632 pub fn closure_bare_wrapper_cache
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<ValueRef
, ValueRef
>> {
633 &self.local
.closure_bare_wrapper_cache
636 pub fn lltypes
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<Ty
<'tcx
>, Type
>> {
640 pub fn llsizingtypes
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<Ty
<'tcx
>, Type
>> {
641 &self.local
.llsizingtypes
644 pub fn adt_reprs
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<Ty
<'tcx
>, Rc
<adt
::Repr
<'tcx
>>>> {
645 &self.local
.adt_reprs
648 pub fn symbol_hasher
<'a
>(&'a
self) -> &'a RefCell
<Sha256
> {
649 &self.shared
.symbol_hasher
652 pub fn type_hashcodes
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<Ty
<'tcx
>, String
>> {
653 &self.local
.type_hashcodes
656 pub fn stats
<'a
>(&'a
self) -> &'a Stats
{
660 pub fn available_monomorphizations
<'a
>(&'a
self) -> &'a RefCell
<FnvHashSet
<String
>> {
661 &self.shared
.available_monomorphizations
664 pub fn available_drop_glues(&self) -> &RefCell
<FnvHashMap
<DropGlueKind
<'tcx
>, String
>> {
665 &self.shared
.available_drop_glues
668 pub fn int_type(&self) -> Type
{
672 pub fn opaque_vec_type(&self) -> Type
{
673 self.local
.opaque_vec_type
676 pub fn closure_vals
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<MonoId
<'tcx
>, ValueRef
>> {
677 &self.local
.closure_vals
680 pub fn dbg_cx
<'a
>(&'a
self) -> &'a Option
<debuginfo
::CrateDebugContext
<'tcx
>> {
684 pub fn eh_personality
<'a
>(&'a
self) -> &'a RefCell
<Option
<ValueRef
>> {
685 &self.local
.eh_personality
688 fn intrinsics
<'a
>(&'a
self) -> &'a RefCell
<FnvHashMap
<&'
static str, ValueRef
>> {
689 &self.local
.intrinsics
692 pub fn count_llvm_insn(&self) {
693 self.local
.n_llvm_insns
.set(self.local
.n_llvm_insns
.get() + 1);
696 pub fn trait_cache(&self) -> &RefCell
<FnvHashMap
<ty
::PolyTraitRef
<'tcx
>,
697 traits
::Vtable
<'tcx
, ()>>> {
698 &self.local
.trait_cache
701 /// Return exclusive upper bound on object size.
703 /// The theoretical maximum object size is defined as the maximum positive `int` value. This
704 /// ensures that the `offset` semantics remain well-defined by allowing it to correctly index
705 /// every address within an object along with one byte past the end, along with allowing `int`
706 /// to store the difference between any two pointers into an object.
708 /// The upper bound on 64-bit currently needs to be lower because LLVM uses a 64-bit integer to
709 /// represent object size in bits. It would need to be 1 << 61 to account for this, but is
710 /// currently conservatively bounded to 1 << 47 as that is enough to cover the current usable
711 /// address space on 64-bit ARMv8 and x86_64.
712 pub fn obj_size_bound(&self) -> u64 {
713 match &self.sess().target
.target
.target_pointer_width
[..] {
716 _
=> unreachable
!() // error handled by config::build_target_config
720 pub fn report_overbig_object(&self, obj
: Ty
<'tcx
>) -> ! {
722 &format
!("the type `{}` is too big for the current architecture",
723 obj
.repr(self.tcx())))
726 pub fn check_overflow(&self) -> bool
{
727 self.shared
.check_overflow
730 pub fn check_drop_flag_for_sanity(&self) -> bool
{
731 // This controls whether we emit a conditional llvm.debugtrap
732 // guarded on whether the dropflag is one of its (two) valid
734 self.shared
.check_drop_flag_for_sanity
738 /// Declare any llvm intrinsics that you might need
739 fn declare_intrinsic(ccx
: &CrateContext
, key
: & &'
static str) -> Option
<ValueRef
> {
741 ($name
:expr
, fn() -> $ret
:expr
) => (
743 let f
= declare
::declare_cfn(ccx
, $name
, Type
::func(&[], &$ret
),
744 ty
::mk_nil(ccx
.tcx()));
745 ccx
.intrinsics().borrow_mut().insert($name
, f
.clone());
749 ($name
:expr
, fn($
($arg
:expr
),*) -> $ret
:expr
) => (
751 let f
= declare
::declare_cfn(ccx
, $name
, Type
::func(&[$
($arg
),*], &$ret
),
752 ty
::mk_nil(ccx
.tcx()));
753 ccx
.intrinsics().borrow_mut().insert($name
, f
.clone());
758 macro_rules
! mk_struct
{
759 ($
($field_ty
:expr
),*) => (Type
::struct_(ccx
, &[$
($field_ty
),*], false))
762 let i8p
= Type
::i8p(ccx
);
763 let void
= Type
::void(ccx
);
764 let i1
= Type
::i1(ccx
);
765 let t_i8
= Type
::i8(ccx
);
766 let t_i16
= Type
::i16(ccx
);
767 let t_i32
= Type
::i32(ccx
);
768 let t_i64
= Type
::i64(ccx
);
769 let t_f32
= Type
::f32(ccx
);
770 let t_f64
= Type
::f64(ccx
);
772 ifn
!("llvm.memcpy.p0i8.p0i8.i32", fn(i8p
, i8p
, t_i32
, t_i32
, i1
) -> void
);
773 ifn
!("llvm.memcpy.p0i8.p0i8.i64", fn(i8p
, i8p
, t_i64
, t_i32
, i1
) -> void
);
774 ifn
!("llvm.memmove.p0i8.p0i8.i32", fn(i8p
, i8p
, t_i32
, t_i32
, i1
) -> void
);
775 ifn
!("llvm.memmove.p0i8.p0i8.i64", fn(i8p
, i8p
, t_i64
, t_i32
, i1
) -> void
);
776 ifn
!("llvm.memset.p0i8.i32", fn(i8p
, t_i8
, t_i32
, t_i32
, i1
) -> void
);
777 ifn
!("llvm.memset.p0i8.i64", fn(i8p
, t_i8
, t_i64
, t_i32
, i1
) -> void
);
779 ifn
!("llvm.trap", fn() -> void
);
780 ifn
!("llvm.debugtrap", fn() -> void
);
781 ifn
!("llvm.frameaddress", fn(t_i32
) -> i8p
);
783 ifn
!("llvm.powi.f32", fn(t_f32
, t_i32
) -> t_f32
);
784 ifn
!("llvm.powi.f64", fn(t_f64
, t_i32
) -> t_f64
);
785 ifn
!("llvm.pow.f32", fn(t_f32
, t_f32
) -> t_f32
);
786 ifn
!("llvm.pow.f64", fn(t_f64
, t_f64
) -> t_f64
);
788 ifn
!("llvm.sqrt.f32", fn(t_f32
) -> t_f32
);
789 ifn
!("llvm.sqrt.f64", fn(t_f64
) -> t_f64
);
790 ifn
!("llvm.sin.f32", fn(t_f32
) -> t_f32
);
791 ifn
!("llvm.sin.f64", fn(t_f64
) -> t_f64
);
792 ifn
!("llvm.cos.f32", fn(t_f32
) -> t_f32
);
793 ifn
!("llvm.cos.f64", fn(t_f64
) -> t_f64
);
794 ifn
!("llvm.exp.f32", fn(t_f32
) -> t_f32
);
795 ifn
!("llvm.exp.f64", fn(t_f64
) -> t_f64
);
796 ifn
!("llvm.exp2.f32", fn(t_f32
) -> t_f32
);
797 ifn
!("llvm.exp2.f64", fn(t_f64
) -> t_f64
);
798 ifn
!("llvm.log.f32", fn(t_f32
) -> t_f32
);
799 ifn
!("llvm.log.f64", fn(t_f64
) -> t_f64
);
800 ifn
!("llvm.log10.f32", fn(t_f32
) -> t_f32
);
801 ifn
!("llvm.log10.f64", fn(t_f64
) -> t_f64
);
802 ifn
!("llvm.log2.f32", fn(t_f32
) -> t_f32
);
803 ifn
!("llvm.log2.f64", fn(t_f64
) -> t_f64
);
805 ifn
!("llvm.fma.f32", fn(t_f32
, t_f32
, t_f32
) -> t_f32
);
806 ifn
!("llvm.fma.f64", fn(t_f64
, t_f64
, t_f64
) -> t_f64
);
808 ifn
!("llvm.fabs.f32", fn(t_f32
) -> t_f32
);
809 ifn
!("llvm.fabs.f64", fn(t_f64
) -> t_f64
);
811 ifn
!("llvm.floor.f32", fn(t_f32
) -> t_f32
);
812 ifn
!("llvm.floor.f64", fn(t_f64
) -> t_f64
);
813 ifn
!("llvm.ceil.f32", fn(t_f32
) -> t_f32
);
814 ifn
!("llvm.ceil.f64", fn(t_f64
) -> t_f64
);
815 ifn
!("llvm.trunc.f32", fn(t_f32
) -> t_f32
);
816 ifn
!("llvm.trunc.f64", fn(t_f64
) -> t_f64
);
818 ifn
!("llvm.rint.f32", fn(t_f32
) -> t_f32
);
819 ifn
!("llvm.rint.f64", fn(t_f64
) -> t_f64
);
820 ifn
!("llvm.nearbyint.f32", fn(t_f32
) -> t_f32
);
821 ifn
!("llvm.nearbyint.f64", fn(t_f64
) -> t_f64
);
823 ifn
!("llvm.ctpop.i8", fn(t_i8
) -> t_i8
);
824 ifn
!("llvm.ctpop.i16", fn(t_i16
) -> t_i16
);
825 ifn
!("llvm.ctpop.i32", fn(t_i32
) -> t_i32
);
826 ifn
!("llvm.ctpop.i64", fn(t_i64
) -> t_i64
);
828 ifn
!("llvm.ctlz.i8", fn(t_i8
, i1
) -> t_i8
);
829 ifn
!("llvm.ctlz.i16", fn(t_i16
, i1
) -> t_i16
);
830 ifn
!("llvm.ctlz.i32", fn(t_i32
, i1
) -> t_i32
);
831 ifn
!("llvm.ctlz.i64", fn(t_i64
, i1
) -> t_i64
);
833 ifn
!("llvm.cttz.i8", fn(t_i8
, i1
) -> t_i8
);
834 ifn
!("llvm.cttz.i16", fn(t_i16
, i1
) -> t_i16
);
835 ifn
!("llvm.cttz.i32", fn(t_i32
, i1
) -> t_i32
);
836 ifn
!("llvm.cttz.i64", fn(t_i64
, i1
) -> t_i64
);
838 ifn
!("llvm.bswap.i16", fn(t_i16
) -> t_i16
);
839 ifn
!("llvm.bswap.i32", fn(t_i32
) -> t_i32
);
840 ifn
!("llvm.bswap.i64", fn(t_i64
) -> t_i64
);
842 ifn
!("llvm.sadd.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
843 ifn
!("llvm.sadd.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
844 ifn
!("llvm.sadd.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
845 ifn
!("llvm.sadd.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
847 ifn
!("llvm.uadd.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
848 ifn
!("llvm.uadd.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
849 ifn
!("llvm.uadd.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
850 ifn
!("llvm.uadd.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
852 ifn
!("llvm.ssub.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
853 ifn
!("llvm.ssub.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
854 ifn
!("llvm.ssub.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
855 ifn
!("llvm.ssub.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
857 ifn
!("llvm.usub.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
858 ifn
!("llvm.usub.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
859 ifn
!("llvm.usub.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
860 ifn
!("llvm.usub.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
862 ifn
!("llvm.smul.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
863 ifn
!("llvm.smul.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
864 ifn
!("llvm.smul.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
865 ifn
!("llvm.smul.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
867 ifn
!("llvm.umul.with.overflow.i8", fn(t_i8
, t_i8
) -> mk_struct
!{t_i8, i1}
);
868 ifn
!("llvm.umul.with.overflow.i16", fn(t_i16
, t_i16
) -> mk_struct
!{t_i16, i1}
);
869 ifn
!("llvm.umul.with.overflow.i32", fn(t_i32
, t_i32
) -> mk_struct
!{t_i32, i1}
);
870 ifn
!("llvm.umul.with.overflow.i64", fn(t_i64
, t_i64
) -> mk_struct
!{t_i64, i1}
);
872 ifn
!("llvm.lifetime.start", fn(t_i64
,i8p
) -> void
);
873 ifn
!("llvm.lifetime.end", fn(t_i64
, i8p
) -> void
);
875 ifn
!("llvm.expect.i1", fn(i1
, i1
) -> i1
);
876 ifn
!("llvm.assume", fn(i1
) -> void
);
878 // Some intrinsics were introduced in later versions of LLVM, but they have
879 // fallbacks in libc or libm and such. Currently, all of these intrinsics
880 // were introduced in LLVM 3.4, so we case on that.
881 macro_rules
! compatible_ifn
{
882 ($name
:expr
, $cname
:ident ($
($arg
:expr
),*) -> $ret
:expr
) => (
883 ifn
!($name
, fn($
($arg
),*) -> $ret
);
887 compatible_ifn
!("llvm.copysign.f32", copysignf(t_f32
, t_f32
) -> t_f32
);
888 compatible_ifn
!("llvm.copysign.f64", copysign(t_f64
, t_f64
) -> t_f64
);
889 compatible_ifn
!("llvm.round.f32", roundf(t_f32
) -> t_f32
);
890 compatible_ifn
!("llvm.round.f64", round(t_f64
) -> t_f64
);
893 if ccx
.sess().opts
.debuginfo
!= NoDebugInfo
{
894 ifn
!("llvm.dbg.declare", fn(Type
::metadata(ccx
), Type
::metadata(ccx
)) -> void
);
895 ifn
!("llvm.dbg.value", fn(Type
::metadata(ccx
), t_i64
, Type
::metadata(ccx
)) -> void
);