2013-06-13 02:19:50 -05:00
|
|
|
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2014-05-06 06:38:01 -05:00
|
|
|
use driver::config::NoDebugInfo;
|
2014-03-05 08:36:01 -06:00
|
|
|
use driver::session::Session;
|
2014-07-07 19:58:01 -05:00
|
|
|
use llvm;
|
2014-09-05 11:18:53 -05:00
|
|
|
use llvm::{ContextRef, ModuleRef, ValueRef, BuilderRef};
|
2014-07-07 19:58:01 -05:00
|
|
|
use llvm::{TargetData};
|
|
|
|
use llvm::mk_target_data;
|
2013-06-12 21:02:33 -05:00
|
|
|
use metadata::common::LinkMeta;
|
|
|
|
use middle::resolve;
|
2014-09-12 10:42:58 -05:00
|
|
|
use middle::traits;
|
2013-06-12 21:02:33 -05:00
|
|
|
use middle::trans::adt;
|
|
|
|
use middle::trans::base;
|
2013-07-21 08:33:40 -05:00
|
|
|
use middle::trans::builder::Builder;
|
2014-04-21 19:25:56 -05:00
|
|
|
use middle::trans::common::{ExternMap,tydesc_info,BuilderRef_res};
|
2014-01-10 16:02:36 -06:00
|
|
|
use middle::trans::debuginfo;
|
2014-04-20 11:29:56 -05:00
|
|
|
use middle::trans::monomorphize::MonoId;
|
2014-07-05 15:24:57 -05:00
|
|
|
use middle::trans::type_::{Type, TypeNames};
|
2014-01-10 16:02:36 -06:00
|
|
|
use middle::ty;
|
2013-12-09 15:56:53 -06:00
|
|
|
use util::sha2::Sha256;
|
2014-02-28 16:34:26 -06:00
|
|
|
use util::nodemap::{NodeMap, NodeSet, DefIdMap};
|
2013-12-09 15:56:53 -06:00
|
|
|
|
2013-12-18 20:35:33 -06:00
|
|
|
use std::cell::{Cell, RefCell};
|
2013-08-03 19:13:14 -05:00
|
|
|
use std::c_str::ToCStr;
|
2014-03-15 15:29:34 -05:00
|
|
|
use std::ptr;
|
2014-04-21 19:03:02 -05:00
|
|
|
use std::rc::Rc;
|
2014-05-29 21:03:06 -05:00
|
|
|
use std::collections::{HashMap, HashSet};
|
2014-05-12 12:03:34 -05:00
|
|
|
use syntax::abi;
|
2013-06-12 21:49:01 -05:00
|
|
|
use syntax::ast;
|
2014-01-10 16:02:36 -06:00
|
|
|
use syntax::parse::token::InternedString;
|
2013-06-12 21:49:01 -05:00
|
|
|
|
2014-04-21 19:25:56 -05:00
|
|
|
pub struct Stats {
|
|
|
|
pub n_static_tydescs: Cell<uint>,
|
|
|
|
pub n_glues_created: Cell<uint>,
|
|
|
|
pub n_null_glues: Cell<uint>,
|
|
|
|
pub n_real_glues: Cell<uint>,
|
|
|
|
pub n_fns: Cell<uint>,
|
|
|
|
pub n_monos: Cell<uint>,
|
|
|
|
pub n_inlines: Cell<uint>,
|
|
|
|
pub n_closures: Cell<uint>,
|
|
|
|
pub n_llvm_insns: Cell<uint>,
|
2014-05-22 18:57:53 -05:00
|
|
|
pub llvm_insns: RefCell<HashMap<String, uint>>,
|
2014-04-21 19:25:56 -05:00
|
|
|
// (ident, time-in-ms, llvm-instructions)
|
2014-05-22 18:57:53 -05:00
|
|
|
pub fn_stats: RefCell<Vec<(String, uint, uint)> >,
|
2014-04-21 19:25:56 -05:00
|
|
|
}
|
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
/// The shared portion of a `CrateContext`. There is one `SharedCrateContext`
|
|
|
|
/// per crate. The data here is shared between all compilation units of the
|
|
|
|
/// crate, so it must not contain references to any LLVM data structures
|
|
|
|
/// (aside from metadata-related ones).
|
2014-04-22 07:56:37 -05:00
|
|
|
pub struct SharedCrateContext<'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
local_ccxs: Vec<LocalCrateContext>,
|
|
|
|
|
|
|
|
metadata_llmod: ModuleRef,
|
|
|
|
metadata_llcx: ContextRef,
|
|
|
|
|
|
|
|
exp_map2: resolve::ExportMap2,
|
|
|
|
reachable: NodeSet,
|
|
|
|
item_symbols: RefCell<NodeMap<String>>,
|
|
|
|
link_meta: LinkMeta,
|
|
|
|
symbol_hasher: RefCell<Sha256>,
|
2014-04-22 07:56:37 -05:00
|
|
|
tcx: ty::ctxt<'tcx>,
|
2014-07-16 13:27:57 -05:00
|
|
|
stats: Stats,
|
2014-07-31 18:45:29 -05:00
|
|
|
|
|
|
|
available_monomorphizations: RefCell<HashSet<String>>,
|
|
|
|
available_drop_glues: RefCell<HashMap<ty::t, String>>,
|
|
|
|
available_visit_glues: RefCell<HashMap<ty::t, String>>,
|
2014-07-16 13:27:57 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/// The local portion of a `CrateContext`. There is one `LocalCrateContext`
|
|
|
|
/// per compilation unit. Each one has its own LLVM `ContextRef` so that
|
|
|
|
/// several compilation units may be optimized in parallel. All other LLVM
|
|
|
|
/// data structures in the `LocalCrateContext` are tied to that `ContextRef`.
|
|
|
|
pub struct LocalCrateContext {
|
2014-09-05 11:18:53 -05:00
|
|
|
llmod: ModuleRef,
|
|
|
|
llcx: ContextRef,
|
|
|
|
td: TargetData,
|
|
|
|
tn: TypeNames,
|
|
|
|
externs: RefCell<ExternMap>,
|
|
|
|
item_vals: RefCell<NodeMap<ValueRef>>,
|
|
|
|
drop_glues: RefCell<HashMap<ty::t, ValueRef>>,
|
|
|
|
tydescs: RefCell<HashMap<ty::t, Rc<tydesc_info>>>,
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Set when running emit_tydescs to enforce that no more tydescs are
|
|
|
|
/// created.
|
2014-09-05 11:18:53 -05:00
|
|
|
finished_tydescs: Cell<bool>,
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Track mapping of external ids to local items imported for inlining
|
2014-09-05 11:18:53 -05:00
|
|
|
external: RefCell<DefIdMap<Option<ast::NodeId>>>,
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Backwards version of the `external` map (inlined items to where they
|
|
|
|
/// came from)
|
2014-09-05 11:18:53 -05:00
|
|
|
external_srcs: RefCell<NodeMap<ast::DefId>>,
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Cache instances of monomorphized functions
|
2014-09-05 11:18:53 -05:00
|
|
|
monomorphized: RefCell<HashMap<MonoId, ValueRef>>,
|
|
|
|
monomorphizing: RefCell<DefIdMap<uint>>,
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Cache generated vtables
|
2014-09-12 10:42:58 -05:00
|
|
|
vtables: RefCell<HashMap<(ty::t,Rc<ty::TraitRef>), ValueRef>>,
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Cache of constant strings,
|
2014-09-05 11:18:53 -05:00
|
|
|
const_cstr_cache: RefCell<HashMap<InternedString, ValueRef>>,
|
2013-06-12 21:02:33 -05:00
|
|
|
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Reverse-direction for const ptrs cast from globals.
|
|
|
|
/// Key is an int, cast from a ValueRef holding a *T,
|
|
|
|
/// Val is a ValueRef holding a *[T].
|
|
|
|
///
|
|
|
|
/// Needed because LLVM loses pointer->pointee association
|
|
|
|
/// when we ptrcast, and we have to ptrcast during translation
|
|
|
|
/// of a [T] const because we form a slice, a [*T,int] pair, not
|
|
|
|
/// a pointer to an LLVM array type.
|
2014-09-05 11:18:53 -05:00
|
|
|
const_globals: RefCell<HashMap<int, ValueRef>>,
|
2013-06-12 21:02:33 -05:00
|
|
|
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Cache of emitted const values
|
2014-09-05 11:18:53 -05:00
|
|
|
const_values: RefCell<NodeMap<ValueRef>>,
|
2013-06-12 21:02:33 -05:00
|
|
|
|
rustc: Add `const` globals to the language
This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.
The semantics of these three kinds of globals are:
* A `const` does not represent a memory location, but only a value. Constants
are translated as rvalues, which means that their values are directly inlined
at usage location (similar to a #define in C/C++). Constant values are, well,
constant, and can not be modified. Any "modification" is actually a
modification to a local value on the stack rather than the actual constant
itself.
Almost all values are allowed inside constants, whether they have interior
mutability or not. There are a few minor restrictions listed in the RFC, but
they should in general not come up too often.
* A `static` now always represents a memory location (unconditionally). Any
references to the same `static` are actually a reference to the same memory
location. Only values whose types ascribe to `Sync` are allowed in a `static`.
This restriction is in place because many threads may access a `static`
concurrently. Lifting this restriction (and allowing unsafe access) is a
future extension not implemented at this time.
* A `static mut` continues to always represent a memory location. All references
to a `static mut` continue to be `unsafe`.
This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:
* Statics may no longer be used in patterns. Statics now always represent a
memory location, which can sometimes be modified. To fix code, repurpose the
matched-on-`static` to a `const`.
static FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
change this code to:
const FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
* Statics may no longer refer to other statics by value. Due to statics being
able to change at runtime, allowing them to reference one another could
possibly lead to confusing semantics. If you are in this situation, use a
constant initializer instead. Note, however, that statics may reference other
statics by address, however.
* Statics may no longer be used in constant expressions, such as array lengths.
This is due to the same restrictions as listed above. Use a `const` instead.
[breaking-change]
[rfc]: https://github.com/rust-lang/rfcs/pull/246
2014-10-06 10:17:01 -05:00
|
|
|
/// Cache of emitted static values
|
|
|
|
static_values: RefCell<NodeMap<ValueRef>>,
|
|
|
|
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Cache of external const values
|
2014-09-05 11:18:53 -05:00
|
|
|
extern_const_values: RefCell<DefIdMap<ValueRef>>,
|
2013-06-12 21:02:33 -05:00
|
|
|
|
2014-09-05 11:18:53 -05:00
|
|
|
impl_method_cache: RefCell<HashMap<(ast::DefId, ast::Name), ast::DefId>>,
|
2013-06-14 00:38:17 -05:00
|
|
|
|
2014-04-01 06:11:23 -05:00
|
|
|
/// Cache of closure wrappers for bare fn's.
|
2014-09-05 11:18:53 -05:00
|
|
|
closure_bare_wrapper_cache: RefCell<HashMap<ValueRef, ValueRef>>,
|
|
|
|
|
|
|
|
lltypes: RefCell<HashMap<ty::t, Type>>,
|
|
|
|
llsizingtypes: RefCell<HashMap<ty::t, Type>>,
|
|
|
|
adt_reprs: RefCell<HashMap<ty::t, Rc<adt::Repr>>>,
|
|
|
|
type_hashcodes: RefCell<HashMap<ty::t, String>>,
|
|
|
|
all_llvm_symbols: RefCell<HashSet<String>>,
|
|
|
|
int_type: Type,
|
|
|
|
opaque_vec_type: Type,
|
|
|
|
builder: BuilderRef_res,
|
2014-05-29 00:26:56 -05:00
|
|
|
|
|
|
|
/// Holds the LLVM values for closure IDs.
|
2014-09-05 11:18:53 -05:00
|
|
|
unboxed_closure_vals: RefCell<DefIdMap<ValueRef>>,
|
2014-05-29 00:26:56 -05:00
|
|
|
|
2014-09-05 11:18:53 -05:00
|
|
|
dbg_cx: Option<debuginfo::CrateDebugContext>,
|
2014-04-09 18:56:31 -05:00
|
|
|
|
2014-09-05 11:18:53 -05:00
|
|
|
eh_personality: RefCell<Option<ValueRef>>,
|
2014-05-19 11:30:09 -05:00
|
|
|
|
2014-04-09 18:56:31 -05:00
|
|
|
intrinsics: RefCell<HashMap<&'static str, ValueRef>>,
|
2014-07-21 18:42:34 -05:00
|
|
|
|
|
|
|
/// Number of LLVM instructions translated into this `LocalCrateContext`.
|
|
|
|
/// This is used to perform some basic load-balancing to keep all LLVM
|
|
|
|
/// contexts around the same size.
|
|
|
|
n_llvm_insns: Cell<uint>,
|
2014-09-12 10:42:58 -05:00
|
|
|
|
|
|
|
trait_cache: RefCell<HashMap<Rc<ty::TraitRef>,
|
|
|
|
traits::Vtable<()>>>,
|
2013-06-12 21:02:33 -05:00
|
|
|
}
|
2013-06-12 21:49:01 -05:00
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub struct CrateContext<'a, 'tcx: 'a> {
|
|
|
|
shared: &'a SharedCrateContext<'tcx>,
|
2014-07-16 13:27:57 -05:00
|
|
|
local: &'a LocalCrateContext,
|
2014-08-01 14:27:12 -05:00
|
|
|
/// The index of `local` in `shared.local_ccxs`. This is used in
|
|
|
|
/// `maybe_iter(true)` to identify the original `LocalCrateContext`.
|
|
|
|
index: uint,
|
2014-07-16 13:27:57 -05:00
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub struct CrateContextIterator<'a, 'tcx: 'a> {
|
|
|
|
shared: &'a SharedCrateContext<'tcx>,
|
run optimization and codegen on worker threads
Refactor the code in `llvm::back` that invokes LLVM optimization and codegen
passes so that it can be called from worker threads. (Previously, it used
`&Session` extensively, and `Session` is not `Share`.) The new code can handle
multiple compilation units, by compiling each unit to `crate.0.o`, `crate.1.o`,
etc., and linking together all the `crate.N.o` files into a single `crate.o`
using `ld -r`. The later linking steps can then be run unchanged.
The new code preserves the behavior of `--emit`/`-o` when building a single
compilation unit. With multiple compilation units, the `--emit=asm/ir/bc`
options produce multiple files, so combinations like `--emit=ir -o foo.ll` will
not actually produce `foo.ll` (they instead produce several `foo.N.ll` files).
The new code supports `-Z lto` only when using a single compilation unit.
Compiling with multiple compilation units and `-Z lto` will produce an error.
(I can't think of any good reason to do such a thing.) Linking with `-Z lto`
against a library that was built as multiple compilation units will also fail,
because the rlib does not contain a `crate.bytecode.deflate` file. This could
be supported in the future by linking together the `crate.N.bc` files produced
when compiling the library into a single `crate.bc`, or by making the LTO code
support multiple `crate.N.bytecode.deflate` files.
2014-07-17 12:52:52 -05:00
|
|
|
index: uint,
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
impl<'a, 'tcx> Iterator<CrateContext<'a, 'tcx>> for CrateContextIterator<'a,'tcx> {
|
|
|
|
fn next(&mut self) -> Option<CrateContext<'a, 'tcx>> {
|
run optimization and codegen on worker threads
Refactor the code in `llvm::back` that invokes LLVM optimization and codegen
passes so that it can be called from worker threads. (Previously, it used
`&Session` extensively, and `Session` is not `Share`.) The new code can handle
multiple compilation units, by compiling each unit to `crate.0.o`, `crate.1.o`,
etc., and linking together all the `crate.N.o` files into a single `crate.o`
using `ld -r`. The later linking steps can then be run unchanged.
The new code preserves the behavior of `--emit`/`-o` when building a single
compilation unit. With multiple compilation units, the `--emit=asm/ir/bc`
options produce multiple files, so combinations like `--emit=ir -o foo.ll` will
not actually produce `foo.ll` (they instead produce several `foo.N.ll` files).
The new code supports `-Z lto` only when using a single compilation unit.
Compiling with multiple compilation units and `-Z lto` will produce an error.
(I can't think of any good reason to do such a thing.) Linking with `-Z lto`
against a library that was built as multiple compilation units will also fail,
because the rlib does not contain a `crate.bytecode.deflate` file. This could
be supported in the future by linking together the `crate.N.bc` files produced
when compiling the library into a single `crate.bc`, or by making the LTO code
support multiple `crate.N.bytecode.deflate` files.
2014-07-17 12:52:52 -05:00
|
|
|
if self.index >= self.shared.local_ccxs.len() {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let index = self.index;
|
|
|
|
self.index += 1;
|
|
|
|
|
|
|
|
Some(CrateContext {
|
|
|
|
shared: self.shared,
|
|
|
|
local: &self.shared.local_ccxs[index],
|
2014-08-01 14:27:12 -05:00
|
|
|
index: index,
|
run optimization and codegen on worker threads
Refactor the code in `llvm::back` that invokes LLVM optimization and codegen
passes so that it can be called from worker threads. (Previously, it used
`&Session` extensively, and `Session` is not `Share`.) The new code can handle
multiple compilation units, by compiling each unit to `crate.0.o`, `crate.1.o`,
etc., and linking together all the `crate.N.o` files into a single `crate.o`
using `ld -r`. The later linking steps can then be run unchanged.
The new code preserves the behavior of `--emit`/`-o` when building a single
compilation unit. With multiple compilation units, the `--emit=asm/ir/bc`
options produce multiple files, so combinations like `--emit=ir -o foo.ll` will
not actually produce `foo.ll` (they instead produce several `foo.N.ll` files).
The new code supports `-Z lto` only when using a single compilation unit.
Compiling with multiple compilation units and `-Z lto` will produce an error.
(I can't think of any good reason to do such a thing.) Linking with `-Z lto`
against a library that was built as multiple compilation units will also fail,
because the rlib does not contain a `crate.bytecode.deflate` file. This could
be supported in the future by linking together the `crate.N.bc` files produced
when compiling the library into a single `crate.bc`, or by making the LTO code
support multiple `crate.N.bytecode.deflate` files.
2014-07-17 12:52:52 -05:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-01 14:27:12 -05:00
|
|
|
/// The iterator produced by `CrateContext::maybe_iter`.
|
2014-04-22 07:56:37 -05:00
|
|
|
pub struct CrateContextMaybeIterator<'a, 'tcx: 'a> {
|
|
|
|
shared: &'a SharedCrateContext<'tcx>,
|
2014-08-01 14:27:12 -05:00
|
|
|
index: uint,
|
|
|
|
single: bool,
|
|
|
|
origin: uint,
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
impl<'a, 'tcx> Iterator<(CrateContext<'a, 'tcx>, bool)> for CrateContextMaybeIterator<'a, 'tcx> {
|
|
|
|
fn next(&mut self) -> Option<(CrateContext<'a, 'tcx>, bool)> {
|
2014-08-01 14:27:12 -05:00
|
|
|
if self.index >= self.shared.local_ccxs.len() {
|
|
|
|
return None;
|
|
|
|
}
|
|
|
|
|
|
|
|
let index = self.index;
|
|
|
|
self.index += 1;
|
|
|
|
if self.single {
|
|
|
|
self.index = self.shared.local_ccxs.len();
|
|
|
|
}
|
|
|
|
|
|
|
|
let ccx = CrateContext {
|
|
|
|
shared: self.shared,
|
|
|
|
local: &self.shared.local_ccxs[index],
|
|
|
|
index: index,
|
|
|
|
};
|
|
|
|
Some((ccx, index == self.origin))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
unsafe fn create_context_and_module(sess: &Session, mod_name: &str) -> (ContextRef, ModuleRef) {
|
|
|
|
let llcx = llvm::LLVMContextCreate();
|
|
|
|
let llmod = mod_name.with_c_str(|buf| {
|
|
|
|
llvm::LLVMModuleCreateWithNameInContext(buf, llcx)
|
|
|
|
});
|
|
|
|
sess.targ_cfg
|
|
|
|
.target_strs
|
|
|
|
.data_layout
|
|
|
|
.as_slice()
|
|
|
|
.with_c_str(|buf| {
|
|
|
|
llvm::LLVMSetDataLayout(llmod, buf);
|
|
|
|
});
|
|
|
|
sess.targ_cfg
|
|
|
|
.target_strs
|
|
|
|
.target_triple
|
|
|
|
.as_slice()
|
|
|
|
.with_c_str(|buf| {
|
|
|
|
llvm::LLVMRustSetNormalizedTarget(llmod, buf);
|
|
|
|
});
|
|
|
|
(llcx, llmod)
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
impl<'tcx> SharedCrateContext<'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
pub fn new(crate_name: &str,
|
|
|
|
local_count: uint,
|
2014-04-22 07:56:37 -05:00
|
|
|
tcx: ty::ctxt<'tcx>,
|
2013-06-18 11:39:16 -05:00
|
|
|
emap2: resolve::ExportMap2,
|
2013-12-09 15:56:53 -06:00
|
|
|
symbol_hasher: Sha256,
|
2013-06-18 11:39:16 -05:00
|
|
|
link_meta: LinkMeta,
|
2014-03-15 15:29:34 -05:00
|
|
|
reachable: NodeSet)
|
2014-04-22 07:56:37 -05:00
|
|
|
-> SharedCrateContext<'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
let (metadata_llcx, metadata_llmod) = unsafe {
|
|
|
|
create_context_and_module(&tcx.sess, "metadata")
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut shared_ccx = SharedCrateContext {
|
|
|
|
local_ccxs: Vec::with_capacity(local_count),
|
|
|
|
metadata_llmod: metadata_llmod,
|
|
|
|
metadata_llcx: metadata_llcx,
|
|
|
|
exp_map2: emap2,
|
|
|
|
reachable: reachable,
|
|
|
|
item_symbols: RefCell::new(NodeMap::new()),
|
|
|
|
link_meta: link_meta,
|
|
|
|
symbol_hasher: RefCell::new(symbol_hasher),
|
|
|
|
tcx: tcx,
|
|
|
|
stats: Stats {
|
|
|
|
n_static_tydescs: Cell::new(0u),
|
|
|
|
n_glues_created: Cell::new(0u),
|
|
|
|
n_null_glues: Cell::new(0u),
|
|
|
|
n_real_glues: Cell::new(0u),
|
|
|
|
n_fns: Cell::new(0u),
|
|
|
|
n_monos: Cell::new(0u),
|
|
|
|
n_inlines: Cell::new(0u),
|
|
|
|
n_closures: Cell::new(0u),
|
|
|
|
n_llvm_insns: Cell::new(0u),
|
|
|
|
llvm_insns: RefCell::new(HashMap::new()),
|
|
|
|
fn_stats: RefCell::new(Vec::new()),
|
|
|
|
},
|
2014-07-31 18:45:29 -05:00
|
|
|
available_monomorphizations: RefCell::new(HashSet::new()),
|
|
|
|
available_drop_glues: RefCell::new(HashMap::new()),
|
|
|
|
available_visit_glues: RefCell::new(HashMap::new()),
|
2014-07-16 13:27:57 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
for i in range(0, local_count) {
|
|
|
|
// Append ".rs" to crate name as LLVM module identifier.
|
|
|
|
//
|
|
|
|
// LLVM code generator emits a ".file filename" directive
|
|
|
|
// for ELF backends. Value of the "filename" is set as the
|
|
|
|
// LLVM module identifier. Due to a LLVM MC bug[1], LLVM
|
|
|
|
// crashes if the module identifier is same as other symbols
|
|
|
|
// such as a function name in the module.
|
|
|
|
// 1. http://llvm.org/bugs/show_bug.cgi?id=11479
|
|
|
|
let llmod_id = format!("{}.{}.rs", crate_name, i);
|
|
|
|
let local_ccx = LocalCrateContext::new(&shared_ccx, llmod_id.as_slice());
|
|
|
|
shared_ccx.local_ccxs.push(local_ccx);
|
|
|
|
}
|
|
|
|
|
|
|
|
shared_ccx
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn iter<'a>(&'a self) -> CrateContextIterator<'a, 'tcx> {
|
run optimization and codegen on worker threads
Refactor the code in `llvm::back` that invokes LLVM optimization and codegen
passes so that it can be called from worker threads. (Previously, it used
`&Session` extensively, and `Session` is not `Share`.) The new code can handle
multiple compilation units, by compiling each unit to `crate.0.o`, `crate.1.o`,
etc., and linking together all the `crate.N.o` files into a single `crate.o`
using `ld -r`. The later linking steps can then be run unchanged.
The new code preserves the behavior of `--emit`/`-o` when building a single
compilation unit. With multiple compilation units, the `--emit=asm/ir/bc`
options produce multiple files, so combinations like `--emit=ir -o foo.ll` will
not actually produce `foo.ll` (they instead produce several `foo.N.ll` files).
The new code supports `-Z lto` only when using a single compilation unit.
Compiling with multiple compilation units and `-Z lto` will produce an error.
(I can't think of any good reason to do such a thing.) Linking with `-Z lto`
against a library that was built as multiple compilation units will also fail,
because the rlib does not contain a `crate.bytecode.deflate` file. This could
be supported in the future by linking together the `crate.N.bc` files produced
when compiling the library into a single `crate.bc`, or by making the LTO code
support multiple `crate.N.bytecode.deflate` files.
2014-07-17 12:52:52 -05:00
|
|
|
CrateContextIterator {
|
|
|
|
shared: self,
|
|
|
|
index: 0,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn get_ccx<'a>(&'a self, index: uint) -> CrateContext<'a, 'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
CrateContext {
|
|
|
|
shared: self,
|
|
|
|
local: &self.local_ccxs[index],
|
2014-08-01 14:27:12 -05:00
|
|
|
index: index,
|
2014-07-16 13:27:57 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
fn get_smallest_ccx<'a>(&'a self) -> CrateContext<'a, 'tcx> {
|
2014-08-01 14:27:12 -05:00
|
|
|
let (local_ccx, index) =
|
2014-07-21 18:42:34 -05:00
|
|
|
self.local_ccxs
|
|
|
|
.iter()
|
2014-08-01 14:27:12 -05:00
|
|
|
.zip(range(0, self.local_ccxs.len()))
|
|
|
|
.min_by(|&(local_ccx, _idx)| local_ccx.n_llvm_insns.get())
|
2014-07-21 18:42:34 -05:00
|
|
|
.unwrap();
|
|
|
|
CrateContext {
|
|
|
|
shared: self,
|
|
|
|
local: local_ccx,
|
2014-08-01 14:27:12 -05:00
|
|
|
index: index,
|
2014-07-21 18:42:34 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
|
|
|
|
pub fn metadata_llmod(&self) -> ModuleRef {
|
|
|
|
self.metadata_llmod
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn metadata_llcx(&self) -> ContextRef {
|
|
|
|
self.metadata_llcx
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn exp_map2<'a>(&'a self) -> &'a resolve::ExportMap2 {
|
|
|
|
&self.exp_map2
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn reachable<'a>(&'a self) -> &'a NodeSet {
|
|
|
|
&self.reachable
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn item_symbols<'a>(&'a self) -> &'a RefCell<NodeMap<String>> {
|
|
|
|
&self.item_symbols
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn link_meta<'a>(&'a self) -> &'a LinkMeta {
|
|
|
|
&self.link_meta
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn symbol_hasher<'a>(&'a self) -> &'a RefCell<Sha256> {
|
|
|
|
&self.symbol_hasher
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.tcx
|
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn take_tcx(self) -> ty::ctxt<'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.tcx
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn sess<'a>(&'a self) -> &'a Session {
|
|
|
|
&self.tcx.sess
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn stats<'a>(&'a self) -> &'a Stats {
|
|
|
|
&self.stats
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl LocalCrateContext {
|
|
|
|
fn new(shared: &SharedCrateContext,
|
|
|
|
name: &str)
|
|
|
|
-> LocalCrateContext {
|
2013-06-12 21:49:01 -05:00
|
|
|
unsafe {
|
2014-07-16 13:27:57 -05:00
|
|
|
let (llcx, llmod) = create_context_and_module(&shared.tcx.sess, name);
|
|
|
|
|
|
|
|
let td = mk_target_data(shared.tcx
|
|
|
|
.sess
|
|
|
|
.targ_cfg
|
|
|
|
.target_strs
|
|
|
|
.data_layout
|
|
|
|
.as_slice());
|
|
|
|
|
|
|
|
let dbg_cx = if shared.tcx.sess.opts.debuginfo != NoDebugInfo {
|
2014-01-27 07:58:40 -06:00
|
|
|
Some(debuginfo::CrateDebugContext::new(llmod))
|
2013-06-12 21:49:01 -05:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
};
|
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
let mut local_ccx = LocalCrateContext {
|
2014-03-15 15:29:34 -05:00
|
|
|
llmod: llmod,
|
|
|
|
llcx: llcx,
|
|
|
|
td: td,
|
|
|
|
tn: TypeNames::new(),
|
|
|
|
externs: RefCell::new(HashMap::new()),
|
|
|
|
item_vals: RefCell::new(NodeMap::new()),
|
|
|
|
drop_glues: RefCell::new(HashMap::new()),
|
|
|
|
tydescs: RefCell::new(HashMap::new()),
|
|
|
|
finished_tydescs: Cell::new(false),
|
|
|
|
external: RefCell::new(DefIdMap::new()),
|
|
|
|
external_srcs: RefCell::new(NodeMap::new()),
|
|
|
|
monomorphized: RefCell::new(HashMap::new()),
|
|
|
|
monomorphizing: RefCell::new(DefIdMap::new()),
|
|
|
|
vtables: RefCell::new(HashMap::new()),
|
|
|
|
const_cstr_cache: RefCell::new(HashMap::new()),
|
|
|
|
const_globals: RefCell::new(HashMap::new()),
|
|
|
|
const_values: RefCell::new(NodeMap::new()),
|
rustc: Add `const` globals to the language
This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.
The semantics of these three kinds of globals are:
* A `const` does not represent a memory location, but only a value. Constants
are translated as rvalues, which means that their values are directly inlined
at usage location (similar to a #define in C/C++). Constant values are, well,
constant, and can not be modified. Any "modification" is actually a
modification to a local value on the stack rather than the actual constant
itself.
Almost all values are allowed inside constants, whether they have interior
mutability or not. There are a few minor restrictions listed in the RFC, but
they should in general not come up too often.
* A `static` now always represents a memory location (unconditionally). Any
references to the same `static` are actually a reference to the same memory
location. Only values whose types ascribe to `Sync` are allowed in a `static`.
This restriction is in place because many threads may access a `static`
concurrently. Lifting this restriction (and allowing unsafe access) is a
future extension not implemented at this time.
* A `static mut` continues to always represent a memory location. All references
to a `static mut` continue to be `unsafe`.
This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:
* Statics may no longer be used in patterns. Statics now always represent a
memory location, which can sometimes be modified. To fix code, repurpose the
matched-on-`static` to a `const`.
static FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
change this code to:
const FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
* Statics may no longer refer to other statics by value. Due to statics being
able to change at runtime, allowing them to reference one another could
possibly lead to confusing semantics. If you are in this situation, use a
constant initializer instead. Note, however, that statics may reference other
statics by address, however.
* Statics may no longer be used in constant expressions, such as array lengths.
This is due to the same restrictions as listed above. Use a `const` instead.
[breaking-change]
[rfc]: https://github.com/rust-lang/rfcs/pull/246
2014-10-06 10:17:01 -05:00
|
|
|
static_values: RefCell::new(NodeMap::new()),
|
2014-03-15 15:29:34 -05:00
|
|
|
extern_const_values: RefCell::new(DefIdMap::new()),
|
|
|
|
impl_method_cache: RefCell::new(HashMap::new()),
|
|
|
|
closure_bare_wrapper_cache: RefCell::new(HashMap::new()),
|
|
|
|
lltypes: RefCell::new(HashMap::new()),
|
|
|
|
llsizingtypes: RefCell::new(HashMap::new()),
|
|
|
|
adt_reprs: RefCell::new(HashMap::new()),
|
|
|
|
type_hashcodes: RefCell::new(HashMap::new()),
|
|
|
|
all_llvm_symbols: RefCell::new(HashSet::new()),
|
2014-09-14 22:27:36 -05:00
|
|
|
int_type: Type::from_ref(ptr::null_mut()),
|
|
|
|
opaque_vec_type: Type::from_ref(ptr::null_mut()),
|
2014-03-15 15:29:34 -05:00
|
|
|
builder: BuilderRef_res(llvm::LLVMCreateBuilderInContext(llcx)),
|
2014-05-29 00:26:56 -05:00
|
|
|
unboxed_closure_vals: RefCell::new(DefIdMap::new()),
|
2014-03-15 15:29:34 -05:00
|
|
|
dbg_cx: dbg_cx,
|
2014-05-19 11:30:09 -05:00
|
|
|
eh_personality: RefCell::new(None),
|
2014-04-09 18:56:31 -05:00
|
|
|
intrinsics: RefCell::new(HashMap::new()),
|
2014-07-21 18:42:34 -05:00
|
|
|
n_llvm_insns: Cell::new(0u),
|
2014-09-12 10:42:58 -05:00
|
|
|
trait_cache: RefCell::new(HashMap::new()),
|
2014-03-15 15:29:34 -05:00
|
|
|
};
|
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
local_ccx.int_type = Type::int(&local_ccx.dummy_ccx(shared));
|
|
|
|
local_ccx.opaque_vec_type = Type::opaque_vec(&local_ccx.dummy_ccx(shared));
|
|
|
|
|
|
|
|
// Done mutating local_ccx directly. (The rest of the
|
|
|
|
// initialization goes through RefCell.)
|
|
|
|
{
|
|
|
|
let ccx = local_ccx.dummy_ccx(shared);
|
2014-03-15 15:29:34 -05:00
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
let mut str_slice_ty = Type::named_struct(&ccx, "str_slice");
|
|
|
|
str_slice_ty.set_struct_body([Type::i8p(&ccx), ccx.int_type()], false);
|
|
|
|
ccx.tn().associate_type("str_slice", &str_slice_ty);
|
2014-03-15 15:29:34 -05:00
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
ccx.tn().associate_type("tydesc", &Type::tydesc(&ccx, str_slice_ty));
|
2014-06-08 12:37:45 -05:00
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
if ccx.sess().count_llvm_insns() {
|
|
|
|
base::init_insn_ctxt()
|
|
|
|
}
|
2013-06-16 23:23:24 -05:00
|
|
|
}
|
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
local_ccx
|
2013-06-12 21:49:01 -05:00
|
|
|
}
|
|
|
|
}
|
2013-07-21 08:33:40 -05:00
|
|
|
|
2014-07-16 13:27:57 -05:00
|
|
|
/// Create a dummy `CrateContext` from `self` and the provided
|
|
|
|
/// `SharedCrateContext`. This is somewhat dangerous because `self` may
|
|
|
|
/// not actually be an element of `shared.local_ccxs`, which can cause some
|
|
|
|
/// operations to `fail` unexpectedly.
|
|
|
|
///
|
|
|
|
/// This is used in the `LocalCrateContext` constructor to allow calling
|
|
|
|
/// functions that expect a complete `CrateContext`, even before the local
|
|
|
|
/// portion is fully initialized and attached to the `SharedCrateContext`.
|
2014-04-22 07:56:37 -05:00
|
|
|
fn dummy_ccx<'a, 'tcx>(&'a self, shared: &'a SharedCrateContext<'tcx>)
|
|
|
|
-> CrateContext<'a, 'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
CrateContext {
|
|
|
|
shared: shared,
|
|
|
|
local: self,
|
2014-08-01 14:27:12 -05:00
|
|
|
index: -1 as uint,
|
2014-07-16 13:27:57 -05:00
|
|
|
}
|
2014-03-15 15:29:34 -05:00
|
|
|
}
|
2014-07-16 13:27:57 -05:00
|
|
|
}
|
2014-03-15 15:29:34 -05:00
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
impl<'b, 'tcx> CrateContext<'b, 'tcx> {
|
|
|
|
pub fn shared(&self) -> &'b SharedCrateContext<'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.shared
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn local(&self) -> &'b LocalCrateContext {
|
|
|
|
self.local
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-07-21 18:42:34 -05:00
|
|
|
/// Get a (possibly) different `CrateContext` from the same
|
|
|
|
/// `SharedCrateContext`.
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn rotate(&self) -> CrateContext<'b, 'tcx> {
|
2014-07-21 18:42:34 -05:00
|
|
|
self.shared.get_smallest_ccx()
|
|
|
|
}
|
|
|
|
|
2014-08-01 14:27:12 -05:00
|
|
|
/// Either iterate over only `self`, or iterate over all `CrateContext`s in
|
|
|
|
/// the `SharedCrateContext`. The iterator produces `(ccx, is_origin)`
|
|
|
|
/// pairs, where `is_origin` is `true` if `ccx` is `self` and `false`
|
|
|
|
/// otherwise. This method is useful for avoiding code duplication in
|
|
|
|
/// cases where it may or may not be necessary to translate code into every
|
|
|
|
/// context.
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn maybe_iter(&self, iter_all: bool) -> CrateContextMaybeIterator<'b, 'tcx> {
|
2014-08-01 14:27:12 -05:00
|
|
|
CrateContextMaybeIterator {
|
|
|
|
shared: self.shared,
|
|
|
|
index: if iter_all { 0 } else { self.index },
|
|
|
|
single: !iter_all,
|
|
|
|
origin: self.index,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn tcx<'a>(&'a self) -> &'a ty::ctxt<'tcx> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.tcx
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
2014-03-05 08:36:01 -06:00
|
|
|
pub fn sess<'a>(&'a self) -> &'a Session {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.tcx.sess
|
2014-03-05 08:36:01 -06:00
|
|
|
}
|
|
|
|
|
2014-04-22 07:56:37 -05:00
|
|
|
pub fn builder<'a>(&'a self) -> Builder<'a, 'tcx> {
|
2013-07-21 08:33:40 -05:00
|
|
|
Builder::new(self)
|
|
|
|
}
|
2013-08-11 12:29:14 -05:00
|
|
|
|
2014-09-05 11:18:53 -05:00
|
|
|
pub fn raw_builder<'a>(&'a self) -> BuilderRef {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.local.builder.b
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
2014-03-15 15:29:34 -05:00
|
|
|
pub fn tydesc_type(&self) -> Type {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.local.tn.find_type("tydesc").unwrap()
|
2013-06-12 21:49:01 -05:00
|
|
|
}
|
2014-04-09 18:56:31 -05:00
|
|
|
|
|
|
|
pub fn get_intrinsic(&self, key: & &'static str) -> ValueRef {
|
2014-07-16 13:27:57 -05:00
|
|
|
match self.intrinsics().borrow().find_copy(key) {
|
2014-04-09 18:56:31 -05:00
|
|
|
Some(v) => return v,
|
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
match declare_intrinsic(self, key) {
|
|
|
|
Some(v) => return v,
|
|
|
|
None => fail!()
|
|
|
|
}
|
|
|
|
}
|
2014-05-12 12:03:34 -05:00
|
|
|
|
|
|
|
// Although there is an experimental implementation of LLVM which
|
|
|
|
// supports SS on armv7 it wasn't approved by Apple, see:
|
|
|
|
// http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20140505/216350.html
|
|
|
|
// It looks like it might be never accepted to upstream LLVM.
|
|
|
|
//
|
|
|
|
// So far the decision was to disable them in default builds
|
|
|
|
// but it could be enabled (with patched LLVM)
|
|
|
|
pub fn is_split_stack_supported(&self) -> bool {
|
|
|
|
let ref cfg = self.sess().targ_cfg;
|
2014-09-26 12:11:22 -05:00
|
|
|
(cfg.os != abi::OsiOS || cfg.arch != abi::Arm) && cfg.os != abi::OsWindows
|
2014-05-12 12:03:34 -05:00
|
|
|
}
|
2014-09-05 11:18:53 -05:00
|
|
|
|
|
|
|
|
|
|
|
pub fn llmod(&self) -> ModuleRef {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.local.llmod
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn llcx(&self) -> ContextRef {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.local.llcx
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn td<'a>(&'a self) -> &'a TargetData {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.td
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn tn<'a>(&'a self) -> &'a TypeNames {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.tn
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn externs<'a>(&'a self) -> &'a RefCell<ExternMap> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.externs
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn item_vals<'a>(&'a self) -> &'a RefCell<NodeMap<ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.item_vals
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn exp_map2<'a>(&'a self) -> &'a resolve::ExportMap2 {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.exp_map2
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn reachable<'a>(&'a self) -> &'a NodeSet {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.reachable
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn item_symbols<'a>(&'a self) -> &'a RefCell<NodeMap<String>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.item_symbols
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn link_meta<'a>(&'a self) -> &'a LinkMeta {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.link_meta
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn drop_glues<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.drop_glues
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn tydescs<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Rc<tydesc_info>>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.tydescs
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn finished_tydescs<'a>(&'a self) -> &'a Cell<bool> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.finished_tydescs
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn external<'a>(&'a self) -> &'a RefCell<DefIdMap<Option<ast::NodeId>>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.external
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn external_srcs<'a>(&'a self) -> &'a RefCell<NodeMap<ast::DefId>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.external_srcs
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn monomorphized<'a>(&'a self) -> &'a RefCell<HashMap<MonoId, ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.monomorphized
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn monomorphizing<'a>(&'a self) -> &'a RefCell<DefIdMap<uint>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.monomorphizing
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
2014-09-12 10:42:58 -05:00
|
|
|
pub fn vtables<'a>(&'a self) -> &'a RefCell<HashMap<(ty::t,Rc<ty::TraitRef>), ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.vtables
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn const_cstr_cache<'a>(&'a self) -> &'a RefCell<HashMap<InternedString, ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.const_cstr_cache
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn const_globals<'a>(&'a self) -> &'a RefCell<HashMap<int, ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.const_globals
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn const_values<'a>(&'a self) -> &'a RefCell<NodeMap<ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.const_values
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
rustc: Add `const` globals to the language
This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.
The semantics of these three kinds of globals are:
* A `const` does not represent a memory location, but only a value. Constants
are translated as rvalues, which means that their values are directly inlined
at usage location (similar to a #define in C/C++). Constant values are, well,
constant, and can not be modified. Any "modification" is actually a
modification to a local value on the stack rather than the actual constant
itself.
Almost all values are allowed inside constants, whether they have interior
mutability or not. There are a few minor restrictions listed in the RFC, but
they should in general not come up too often.
* A `static` now always represents a memory location (unconditionally). Any
references to the same `static` are actually a reference to the same memory
location. Only values whose types ascribe to `Sync` are allowed in a `static`.
This restriction is in place because many threads may access a `static`
concurrently. Lifting this restriction (and allowing unsafe access) is a
future extension not implemented at this time.
* A `static mut` continues to always represent a memory location. All references
to a `static mut` continue to be `unsafe`.
This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:
* Statics may no longer be used in patterns. Statics now always represent a
memory location, which can sometimes be modified. To fix code, repurpose the
matched-on-`static` to a `const`.
static FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
change this code to:
const FOO: uint = 4;
match n {
FOO => { /* ... */ }
_ => { /* ... */ }
}
* Statics may no longer refer to other statics by value. Due to statics being
able to change at runtime, allowing them to reference one another could
possibly lead to confusing semantics. If you are in this situation, use a
constant initializer instead. Note, however, that statics may reference other
statics by address, however.
* Statics may no longer be used in constant expressions, such as array lengths.
This is due to the same restrictions as listed above. Use a `const` instead.
[breaking-change]
[rfc]: https://github.com/rust-lang/rfcs/pull/246
2014-10-06 10:17:01 -05:00
|
|
|
pub fn static_values<'a>(&'a self) -> &'a RefCell<NodeMap<ValueRef>> {
|
|
|
|
&self.local.static_values
|
|
|
|
}
|
|
|
|
|
2014-09-05 11:18:53 -05:00
|
|
|
pub fn extern_const_values<'a>(&'a self) -> &'a RefCell<DefIdMap<ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.extern_const_values
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn impl_method_cache<'a>(&'a self)
|
|
|
|
-> &'a RefCell<HashMap<(ast::DefId, ast::Name), ast::DefId>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.impl_method_cache
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn closure_bare_wrapper_cache<'a>(&'a self) -> &'a RefCell<HashMap<ValueRef, ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.closure_bare_wrapper_cache
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn lltypes<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Type>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.lltypes
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn llsizingtypes<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Type>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.llsizingtypes
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn adt_reprs<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, Rc<adt::Repr>>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.adt_reprs
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn symbol_hasher<'a>(&'a self) -> &'a RefCell<Sha256> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.symbol_hasher
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn type_hashcodes<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, String>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.type_hashcodes
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn all_llvm_symbols<'a>(&'a self) -> &'a RefCell<HashSet<String>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.all_llvm_symbols
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn stats<'a>(&'a self) -> &'a Stats {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.shared.stats
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
2014-07-31 18:45:29 -05:00
|
|
|
pub fn available_monomorphizations<'a>(&'a self) -> &'a RefCell<HashSet<String>> {
|
|
|
|
&self.shared.available_monomorphizations
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn available_drop_glues<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, String>> {
|
|
|
|
&self.shared.available_drop_glues
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn available_visit_glues<'a>(&'a self) -> &'a RefCell<HashMap<ty::t, String>> {
|
|
|
|
&self.shared.available_visit_glues
|
|
|
|
}
|
|
|
|
|
2014-09-05 11:18:53 -05:00
|
|
|
pub fn int_type(&self) -> Type {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.local.int_type
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn opaque_vec_type(&self) -> Type {
|
2014-07-16 13:27:57 -05:00
|
|
|
self.local.opaque_vec_type
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn unboxed_closure_vals<'a>(&'a self) -> &'a RefCell<DefIdMap<ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.unboxed_closure_vals
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn dbg_cx<'a>(&'a self) -> &'a Option<debuginfo::CrateDebugContext> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.dbg_cx
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn eh_personality<'a>(&'a self) -> &'a RefCell<Option<ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.eh_personality
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn intrinsics<'a>(&'a self) -> &'a RefCell<HashMap<&'static str, ValueRef>> {
|
2014-07-16 13:27:57 -05:00
|
|
|
&self.local.intrinsics
|
2014-09-05 11:18:53 -05:00
|
|
|
}
|
2014-07-21 18:42:34 -05:00
|
|
|
|
|
|
|
pub fn count_llvm_insn(&self) {
|
|
|
|
self.local.n_llvm_insns.set(self.local.n_llvm_insns.get() + 1);
|
|
|
|
}
|
2014-09-12 10:42:58 -05:00
|
|
|
|
|
|
|
pub fn trait_cache(&self) -> &RefCell<HashMap<Rc<ty::TraitRef>, traits::Vtable<()>>> {
|
|
|
|
&self.local.trait_cache
|
|
|
|
}
|
2014-04-09 18:56:31 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef> {
|
|
|
|
macro_rules! ifn (
|
|
|
|
($name:expr fn() -> $ret:expr) => (
|
|
|
|
if *key == $name {
|
2014-05-12 12:03:34 -05:00
|
|
|
let f = base::decl_cdecl_fn(ccx, $name, Type::func([], &$ret), ty::mk_nil());
|
2014-09-05 11:18:53 -05:00
|
|
|
ccx.intrinsics().borrow_mut().insert($name, f.clone());
|
2014-04-09 18:56:31 -05:00
|
|
|
return Some(f);
|
|
|
|
}
|
|
|
|
);
|
|
|
|
($name:expr fn($($arg:expr),*) -> $ret:expr) => (
|
|
|
|
if *key == $name {
|
2014-05-12 12:03:34 -05:00
|
|
|
let f = base::decl_cdecl_fn(ccx, $name,
|
2014-04-09 18:56:31 -05:00
|
|
|
Type::func([$($arg),*], &$ret), ty::mk_nil());
|
2014-09-05 11:18:53 -05:00
|
|
|
ccx.intrinsics().borrow_mut().insert($name, f.clone());
|
2014-04-09 18:56:31 -05:00
|
|
|
return Some(f);
|
|
|
|
}
|
|
|
|
)
|
|
|
|
)
|
|
|
|
macro_rules! mk_struct (
|
|
|
|
($($field_ty:expr),*) => (Type::struct_(ccx, [$($field_ty),*], false))
|
|
|
|
)
|
|
|
|
|
|
|
|
let i8p = Type::i8p(ccx);
|
|
|
|
let void = Type::void(ccx);
|
|
|
|
let i1 = Type::i1(ccx);
|
|
|
|
let t_i8 = Type::i8(ccx);
|
|
|
|
let t_i16 = Type::i16(ccx);
|
|
|
|
let t_i32 = Type::i32(ccx);
|
|
|
|
let t_i64 = Type::i64(ccx);
|
|
|
|
let t_f32 = Type::f32(ccx);
|
|
|
|
let t_f64 = Type::f64(ccx);
|
|
|
|
|
|
|
|
ifn!("llvm.memcpy.p0i8.p0i8.i32" fn(i8p, i8p, t_i32, t_i32, i1) -> void);
|
|
|
|
ifn!("llvm.memcpy.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void);
|
|
|
|
ifn!("llvm.memmove.p0i8.p0i8.i32" fn(i8p, i8p, t_i32, t_i32, i1) -> void);
|
|
|
|
ifn!("llvm.memmove.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void);
|
|
|
|
ifn!("llvm.memset.p0i8.i32" fn(i8p, t_i8, t_i32, t_i32, i1) -> void);
|
|
|
|
ifn!("llvm.memset.p0i8.i64" fn(i8p, t_i8, t_i64, t_i32, i1) -> void);
|
|
|
|
|
|
|
|
ifn!("llvm.trap" fn() -> void);
|
|
|
|
ifn!("llvm.debugtrap" fn() -> void);
|
|
|
|
ifn!("llvm.frameaddress" fn(t_i32) -> i8p);
|
|
|
|
|
|
|
|
ifn!("llvm.powi.f32" fn(t_f32, t_i32) -> t_f32);
|
|
|
|
ifn!("llvm.powi.f64" fn(t_f64, t_i32) -> t_f64);
|
|
|
|
ifn!("llvm.pow.f32" fn(t_f32, t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.pow.f64" fn(t_f64, t_f64) -> t_f64);
|
|
|
|
|
|
|
|
ifn!("llvm.sqrt.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.sqrt.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.sin.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.sin.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.cos.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.cos.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.exp.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.exp.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.exp2.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.exp2.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.log.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.log.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.log10.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.log10.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.log2.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.log2.f64" fn(t_f64) -> t_f64);
|
|
|
|
|
|
|
|
ifn!("llvm.fma.f32" fn(t_f32, t_f32, t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.fma.f64" fn(t_f64, t_f64, t_f64) -> t_f64);
|
|
|
|
|
|
|
|
ifn!("llvm.fabs.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.fabs.f64" fn(t_f64) -> t_f64);
|
|
|
|
|
|
|
|
ifn!("llvm.floor.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.floor.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.ceil.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.ceil.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.trunc.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.trunc.f64" fn(t_f64) -> t_f64);
|
|
|
|
|
|
|
|
ifn!("llvm.rint.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.rint.f64" fn(t_f64) -> t_f64);
|
|
|
|
ifn!("llvm.nearbyint.f32" fn(t_f32) -> t_f32);
|
|
|
|
ifn!("llvm.nearbyint.f64" fn(t_f64) -> t_f64);
|
|
|
|
|
|
|
|
ifn!("llvm.ctpop.i8" fn(t_i8) -> t_i8);
|
|
|
|
ifn!("llvm.ctpop.i16" fn(t_i16) -> t_i16);
|
|
|
|
ifn!("llvm.ctpop.i32" fn(t_i32) -> t_i32);
|
|
|
|
ifn!("llvm.ctpop.i64" fn(t_i64) -> t_i64);
|
|
|
|
|
|
|
|
ifn!("llvm.ctlz.i8" fn(t_i8 , i1) -> t_i8);
|
|
|
|
ifn!("llvm.ctlz.i16" fn(t_i16, i1) -> t_i16);
|
|
|
|
ifn!("llvm.ctlz.i32" fn(t_i32, i1) -> t_i32);
|
|
|
|
ifn!("llvm.ctlz.i64" fn(t_i64, i1) -> t_i64);
|
|
|
|
|
|
|
|
ifn!("llvm.cttz.i8" fn(t_i8 , i1) -> t_i8);
|
|
|
|
ifn!("llvm.cttz.i16" fn(t_i16, i1) -> t_i16);
|
|
|
|
ifn!("llvm.cttz.i32" fn(t_i32, i1) -> t_i32);
|
|
|
|
ifn!("llvm.cttz.i64" fn(t_i64, i1) -> t_i64);
|
|
|
|
|
|
|
|
ifn!("llvm.bswap.i16" fn(t_i16) -> t_i16);
|
|
|
|
ifn!("llvm.bswap.i32" fn(t_i32) -> t_i32);
|
|
|
|
ifn!("llvm.bswap.i64" fn(t_i64) -> t_i64);
|
|
|
|
|
|
|
|
ifn!("llvm.sadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
|
|
|
|
ifn!("llvm.sadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
|
|
|
|
ifn!("llvm.sadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
|
|
|
|
ifn!("llvm.sadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
|
|
|
|
|
|
|
|
ifn!("llvm.uadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
|
|
|
|
ifn!("llvm.uadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
|
|
|
|
ifn!("llvm.uadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
|
|
|
|
ifn!("llvm.uadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
|
|
|
|
|
|
|
|
ifn!("llvm.ssub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
|
|
|
|
ifn!("llvm.ssub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
|
|
|
|
ifn!("llvm.ssub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
|
|
|
|
ifn!("llvm.ssub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
|
|
|
|
|
|
|
|
ifn!("llvm.usub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
|
|
|
|
ifn!("llvm.usub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
|
|
|
|
ifn!("llvm.usub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
|
|
|
|
ifn!("llvm.usub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
|
|
|
|
|
|
|
|
ifn!("llvm.smul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
|
|
|
|
ifn!("llvm.smul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
|
|
|
|
ifn!("llvm.smul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
|
|
|
|
ifn!("llvm.smul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
|
|
|
|
|
|
|
|
ifn!("llvm.umul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
|
|
|
|
ifn!("llvm.umul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
|
|
|
|
ifn!("llvm.umul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
|
|
|
|
ifn!("llvm.umul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
|
|
|
|
|
Emit LLVM lifetime intrinsics to improve stack usage and codegen in general
Lifetime intrinsics help to reduce stack usage, because LLVM can apply
stack coloring to reuse the stack slots of dead allocas for new ones.
For example these functions now both use the same amount of stack, while
previous `bar()` used five times as much as `foo()`:
````rust
fn foo() {
println("{}", 5);
}
fn bar() {
println("{}", 5);
println("{}", 5);
println("{}", 5);
println("{}", 5);
println("{}", 5);
}
````
On top of that, LLVM can also optimize out certain operations when it
knows that memory is dead after a certain point. For example, it can
sometimes remove the zeroing used to cancel the drop glue. This is
possible when the glue drop itself was already removed because the
zeroing dominated the drop glue call. For example in:
````rust
pub fn bar(x: (Box<int>, int)) -> (Box<int>, int) {
x
}
````
With optimizations, this currently results in:
````llvm
define void @_ZN3bar20h330fa42547df8179niaE({ i64*, i64 }* noalias nocapture nonnull sret, { i64*, i64 }* noalias nocapture nonnull) unnamed_addr #0 {
"_ZN29_$LP$Box$LT$int$GT$$C$int$RP$39glue_drop.$x22glue_drop$x22$LP$1347$RP$17h88cf42702e5a322aE.exit":
%2 = bitcast { i64*, i64 }* %1 to i8*
%3 = bitcast { i64*, i64 }* %0 to i8*
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %3, i8* %2, i64 16, i32 8, i1 false)
tail call void @llvm.memset.p0i8.i64(i8* %2, i8 0, i64 16, i32 8, i1 false)
ret void
}
````
But with lifetime intrinsics we get:
````llvm
define void @_ZN3bar20h330fa42547df8179niaE({ i64*, i64 }* noalias nocapture nonnull sret, { i64*, i64 }* noalias nocapture nonnull) unnamed_addr #0 {
"_ZN29_$LP$Box$LT$int$GT$$C$int$RP$39glue_drop.$x22glue_drop$x22$LP$1347$RP$17h88cf42702e5a322aE.exit":
%2 = bitcast { i64*, i64 }* %1 to i8*
%3 = bitcast { i64*, i64 }* %0 to i8*
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %3, i8* %2, i64 16, i32 8, i1 false)
tail call void @llvm.lifetime.end(i64 16, i8* %2)
ret void
}
````
Fixes #15665
2014-05-01 12:32:07 -05:00
|
|
|
ifn!("llvm.lifetime.start" fn(t_i64,i8p) -> void);
|
|
|
|
ifn!("llvm.lifetime.end" fn(t_i64, i8p) -> void);
|
|
|
|
|
2014-04-09 18:56:31 -05:00
|
|
|
ifn!("llvm.expect.i1" fn(i1, i1) -> i1);
|
|
|
|
|
|
|
|
// Some intrinsics were introduced in later versions of LLVM, but they have
|
|
|
|
// fallbacks in libc or libm and such. Currently, all of these intrinsics
|
|
|
|
// were introduced in LLVM 3.4, so we case on that.
|
|
|
|
macro_rules! compatible_ifn (
|
|
|
|
($name:expr, $cname:ident ($($arg:expr),*) -> $ret:expr) => (
|
|
|
|
if unsafe { llvm::LLVMVersionMinor() >= 4 } {
|
|
|
|
// The `if key == $name` is already in ifn!
|
|
|
|
ifn!($name fn($($arg),*) -> $ret);
|
|
|
|
} else if *key == $name {
|
2014-05-12 12:03:34 -05:00
|
|
|
let f = base::decl_cdecl_fn(ccx, stringify!($cname),
|
2014-04-09 18:56:31 -05:00
|
|
|
Type::func([$($arg),*], &$ret),
|
|
|
|
ty::mk_nil());
|
2014-09-05 11:18:53 -05:00
|
|
|
ccx.intrinsics().borrow_mut().insert($name, f.clone());
|
2014-04-09 18:56:31 -05:00
|
|
|
return Some(f);
|
|
|
|
}
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
|
|
|
compatible_ifn!("llvm.copysign.f32", copysignf(t_f32, t_f32) -> t_f32);
|
|
|
|
compatible_ifn!("llvm.copysign.f64", copysign(t_f64, t_f64) -> t_f64);
|
|
|
|
compatible_ifn!("llvm.round.f32", roundf(t_f32) -> t_f32);
|
|
|
|
compatible_ifn!("llvm.round.f64", round(t_f64) -> t_f64);
|
|
|
|
|
|
|
|
|
|
|
|
if ccx.sess().opts.debuginfo != NoDebugInfo {
|
|
|
|
ifn!("llvm.dbg.declare" fn(Type::metadata(ccx), Type::metadata(ccx)) -> void);
|
|
|
|
ifn!("llvm.dbg.value" fn(Type::metadata(ccx), t_i64, Type::metadata(ccx)) -> void);
|
|
|
|
}
|
|
|
|
return None;
|
2013-06-12 21:49:01 -05:00
|
|
|
}
|