Commit Graph

50369 Commits

Author SHA1 Message Date
bors
53c2933d44 Auto merge of #30900 - michaelwoerister:trans_item_collect, r=nikomatsakis
The purpose of the translation item collector is to find all monomorphic instances of functions, methods and statics that need to be translated into LLVM IR in order to compile the current crate.

So far these instances have been discovered lazily during the trans path. For incremental compilation we want to know the set of these instances in advance, and that is what the trans::collect module provides.
In the future, incremental and regular translation will be driven by the collector implemented here.

r? @nikomatsakis
cc @rust-lang/compiler

Translation Item Collection
===========================

This module is responsible for discovering all items that will contribute to
to code generation of the crate. The important part here is that it not only
needs to find syntax-level items (functions, structs, etc) but also all
their monomorphized instantiations. Every non-generic, non-const function
maps to one LLVM artifact. Every generic function can produce
from zero to N artifacts, depending on the sets of type arguments it
is instantiated with.
This also applies to generic items from other crates: A generic definition
in crate X might produce monomorphizations that are compiled into crate Y.
We also have to collect these here.

The following kinds of "translation items" are handled here:

 - Functions
 - Methods
 - Closures
 - Statics
 - Drop glue

The following things also result in LLVM artifacts, but are not collected
here, since we instantiate them locally on demand when needed in a given
codegen unit:

 - Constants
 - Vtables
 - Object Shims

General Algorithm
-----------------
Let's define some terms first:

 - A "translation item" is something that results in a function or global in
   the LLVM IR of a codegen unit. Translation items do not stand on their
   own, they can reference other translation items. For example, if function
   `foo()` calls function `bar()` then the translation item for `foo()`
   references the translation item for function `bar()`. In general, the
   definition for translation item A referencing a translation item B is that
   the LLVM artifact produced for A references the LLVM artifact produced
   for B.

 - Translation items and the references between them for a directed graph,
   where the translation items are the nodes and references form the edges.
   Let's call this graph the "translation item graph".

 - The translation item graph for a program contains all translation items
   that are needed in order to produce the complete LLVM IR of the program.

The purpose of the algorithm implemented in this module is to build the
translation item graph for the current crate. It runs in two phases:

 1. Discover the roots of the graph by traversing the HIR of the crate.
 2. Starting from the roots, find neighboring nodes by inspecting the MIR
    representation of the item corresponding to a given node, until no more
    new nodes are found.

The roots of the translation item graph correspond to the non-generic
syntactic items in the source code. We find them by walking the HIR of the
crate, and whenever we hit upon a function, method, or static item, we
create a translation item consisting of the items DefId and, since we only
consider non-generic items, an empty type-substitution set.

Given a translation item node, we can discover neighbors by inspecting its
MIR. We walk the MIR and any time we hit upon something that signifies a
reference to another translation item, we have found a neighbor. Since the
translation item we are currently at is always monomorphic, we also know the
concrete type arguments of its neighbors, and so all neighbors again will be
monomorphic. The specific forms a reference to a neighboring node can take
in MIR are quite diverse. Here is an overview:

The most obvious form of one translation item referencing another is a
function or method call (represented by a CALL terminator in MIR). But
calls are not the only thing that might introduce a reference between two
function translation items, and as we will see below, they are just a
specialized of the form described next, and consequently will don't get any
special treatment in the algorithm.

A function does not need to actually be called in order to be a neighbor of
another function. It suffices to just take a reference in order to introduce
an edge. Consider the following example:

```rust
fn print_val<T: Display>(x: T) {
    println!("{}", x);
}

fn call_fn(f: &Fn(i32), x: i32) {
    f(x);
}

fn main() {
    let print_i32 = print_val::<i32>;
    call_fn(&print_i32, 0);
}
```
The MIR of none of these functions will contain an explicit call to
`print_val::<i32>`. Nonetheless, in order to translate this program, we need
an instance of this function. Thus, whenever we encounter a function or
method in operand position, we treat it as a neighbor of the current
translation item. Calls are just a special case of that.

In a way, closures are a simple case. Since every closure object needs to be
constructed somewhere, we can reliably discover them by observing
`RValue::Aggregate` expressions with `AggregateKind::Closure`. This is also
true for closures inlined from other crates.

Drop glue translation items are introduced by MIR drop-statements. The
generated translation item will again have drop-glue item neighbors if the
type to be dropped contains nested values that also need to be dropped. It
might also have a function item neighbor for the explicit `Drop::drop`
implementation of its type.

A subtle way of introducing neighbor edges is by casting to a trait object.
Since the resulting fat-pointer contains a reference to a vtable, we need to
instantiate all object-save methods of the trait, as we need to store
pointers to these functions even if they never get called anywhere. This can
be seen as a special case of taking a function reference.

Since `Box` expression have special compiler support, no explicit calls to
`exchange_malloc()` and `exchange_free()` may show up in MIR, even if the
compiler will generate them. We have to observe `Rvalue::Box` expressions
and Box-typed drop-statements for that purpose.

Interaction with Cross-Crate Inlining
-------------------------------------
The binary of a crate will not only contain machine code for the items
defined in the source code of that crate. It will also contain monomorphic
instantiations of any extern generic functions and of functions marked with
The collection algorithm handles this more or less transparently. When
constructing a neighbor node for an item, the algorithm will always call
`inline::get_local_instance()` before proceeding. If no local instance can
be acquired (e.g. for a function that is just linked to) no node is created;
which is exactly what we want, since no machine code should be generated in
the current crate for such an item. On the other hand, if we can
successfully inline the function, we subsequently can just treat it like a
local item, walking it's MIR et cetera.

Eager and Lazy Collection Mode
------------------------------
Translation item collection can be performed in one of two modes:

 - Lazy mode means that items will only be instantiated when actually
   referenced. The goal is to produce the least amount of machine code
   possible.

 - Eager mode is meant to be used in conjunction with incremental compilation
   where a stable set of translation items is more important than a minimal
   one. Thus, eager mode will instantiate drop-glue for every drop-able type
   in the crate, even of no drop call for that type exists (yet). It will
   also instantiate default implementations of trait methods, something that
   otherwise is only done on demand.

Open Issues
-----------
Some things are not yet fully implemented in the current version of this
module.

Since no MIR is constructed yet for initializer expressions of constants and
statics we cannot inspect these properly.

Ideally, no translation item should be generated for const fns unless there
is a call to them that cannot be evaluated at compile time. At the moment
this is not implemented however: a translation item will be produced
regardless of whether it is actually needed or not.

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/rust-lang/rust/30900)
<!-- Reviewable:end -->
2016-01-29 03:41:44 +00:00
Alex Crichton
acaf151ade std: Fix rumprun build
Looks like the rumprun build has bitrotted over time, so this includes some libc
fixes and some various libstd fixes which gets it back to bootstrapping.
2016-01-28 19:33:48 -08:00
Oliver Middleton
515fac178a rustdoc: Add test for tuple rendering 2016-01-28 23:41:53 +00:00
tgor
77cdeb0437 std::string::String.from_utf16 doc fix 2016-01-29 02:13:34 +03:00
bors
142214d1f2 Auto merge of #30411 - mitaa:multispan, r=nrc
This allows to render multiple spans on one line, or to splice multiple replacements into a code suggestion.

fixes #28124
2016-01-28 22:13:25 +00:00
Ruud van Asseldonk
f841f061ec Improve message for rustc --explain E0507
E0507 can occur when you try to move out of a member of a mutably
borrowed struct, in which case `mem::replace` can help. Mentioning that
here hopefully saves future users a trip to Google.
2016-01-28 22:27:41 +01:00
Ruud van Asseldonk
a7f1d12ae4 Avoid ICE if environment variable is not set
Rustdoc could trigger a code path that relied on the
$CFG_COMPILER_HOST_TRIPLE environment variable being
set, causing an ICE if it was not. This fixes that,
emitting an error instead of crashing.
2016-01-28 22:15:42 +01:00
Oliver Middleton
ad5ab2f360 rustdoc: Add missing trailing comma for single element tuples 2016-01-28 21:02:22 +00:00
mitaa
727f959095 Implement MultiSpan error reporting
This allows to render multiple spans on one line,
or to splice multiple replacements into a code suggestion.
2016-01-28 20:51:06 +01:00
Fabrice Desré
63b4639691 Add support for armv7 toolchains 2016-01-28 09:45:56 -08:00
est31
205f836ab8 Fix reference info about parent doc block comments
Block comments don't have to be in the format `/*! ... !*/`
in order to be read as doc comments about the parent block.
The format `/*! ... */` is enough.
2016-01-28 18:39:39 +01:00
bors
552bf75e7d Auto merge of #31257 - tmiasko:track-errors-fix, r=nikomatsakis
r? @nrc
2016-01-28 17:20:04 +00:00
Tomasz Miąsko
b3e30b5fc3 Fix checking if there have been new errors. 2016-01-28 14:35:00 +01:00
bors
10de8826cd Auto merge of #31241 - tshepang:fix, r=steveklabnik 2016-01-28 11:00:55 +00:00
bors
a891c72976 Auto merge of #31171 - dirk:dirk/safety-section-in-cstring-docs, r=steveklabnik
Also a minor language tweak to the documentation of the `ffi::CString::from_raw` function.
2016-01-28 09:03:00 +00:00
Tomasz Miąsko
9a30ecdf11 libsyntax: fix pretty printing of macro with braces
Pretty printing of macro with braces but without terminated semicolon
removed more boxes from stack than it put there, resulting in panic.
This fixes the issue #30731.
2016-01-28 09:19:43 +01:00
bors
035f4cca00 Auto merge of #31240 - durka:follow-set-docs, r=pnkfelix
Missed as part of #31152, but the list had other mistakes as well.

r? @pnkfelix
2016-01-28 07:06:29 +00:00
Alex Crichton
1a910a0ff3 mk: Remove the -mfpu=vfp4 argument from arm iOS
Unfortunately older clang compilers don't support this argument, so the
bootstrap will fail. We don't actually really need to optimized the C code we
compile, however, as currently we're just compiling jemalloc and not much else.
2016-01-27 22:34:26 -08:00
Jeffrey Seyfried
d2d2144656 Refactor away NameSearchType 2016-01-28 05:07:40 +00:00
Jeffrey Seyfried
1fcde2bdbc Add test for #31212 2016-01-28 05:06:23 +00:00
Jeffrey Seyfried
6ba35cecf6 Resolve: Fix an ICE that occurs when an identifier refers to an indeterminate import (i.e. one that is not resolved and not known to have failed) 2016-01-28 05:06:17 +00:00
Prayag Verma
8c96f37a98 Mention initial copyright year 2016-01-28 09:44:04 +05:30
bors
1c06f64ac2 Auto merge of #31225 - mbrubeck:btreeset-size-hint, r=Gankro
None
2016-01-28 02:21:58 +00:00
Dirk Gadsden
9cfa1916fa Fix formatting in documentation of ffi::CString 2016-01-27 15:07:22 -08:00
bors
38e23e8f7b Auto merge of #31243 - Manishearth:rollup, r=Manishearth
- Successful merges: #30689, #31186, #31219, #31222, #31226
- Failed merges:
2016-01-27 21:32:58 +00:00
Tshepang Lekhonkhobe
bbdef0ce59 rustfmt syntax::parse 2016-01-27 21:45:14 +02:00
Manish Goregaokar
5e7dfa7094 Rollup merge of #31226 - steveklabnik:gh30954, r=Manishearth
Fixes #30954
2016-01-28 00:48:32 +05:30
Manish Goregaokar
d7c57e1fdd Rollup merge of #31222 - durka:patch-15, r=steveklabnik
r? @steveklabnik
2016-01-28 00:48:32 +05:30
Manish Goregaokar
3e56732322 Rollup merge of #31219 - mbrubeck:missing-docs, r=steveklabnik
The missing_docs lint only applies to public items in public modules, so this
example code did not actually generate any warnings or errors.
2016-01-28 00:48:32 +05:30
Manish Goregaokar
cb3680c080 Rollup merge of #31186 - gchp:contributing, r=alexcrichton
I recently wrote a blog post on contributing to the Rust compiler which
gained some interest. It was mentioned in a comment on Reddit that it
would be useful to integrate some of the information from that post to
the official contributing guide.

This is the start of my efforts to integrate what I wrote with the
official guide.

This commit adds information on the build system. It is not a complete
guide on the build system, but it should be enough to provide a good
starting place for those wishing to contribute.
2016-01-28 00:48:31 +05:30
Manish Goregaokar
b29628ac91 Rollup merge of #30689 - Manishearth:lifetime-bound, r=steveklabnik
We should have stuff on this in the book somewhere too

r? @steveklabnik
2016-01-28 00:48:31 +05:30
Tshepang Lekhonkhobe
699c581b84 doc: insert missing chars 2016-01-27 20:56:18 +02:00
Alex Burka
fd4d013a2c trpl: fix macro follow sets 2016-01-27 13:26:47 -05:00
bors
b2f4c5c596 Auto merge of #31224 - bluss:deque-hashing, r=Gankro
Hash VecDeque in its slice parts

Use .as_slices() for a more efficient code path in VecDeque's Hash impl.

This still hashes the elements in the same order.

Before/after timing of VecDeque hashing 1024 elements of u8 and
u64 shows that the vecdeque now can match the Vec
(test_hashing_vec_of_u64 is the Vec run).

```
before

test test_hashing_u64        ... bench:  14,031 ns/iter (+/- 236) = 583 MB/s
test test_hashing_u8         ... bench:   7,887 ns/iter (+/- 65) = 129 MB/s
test test_hashing_vec_of_u64 ... bench:   6,578 ns/iter (+/- 76) = 1245 MB/s

after

running 5 tests
test test_hashing_u64        ... bench:   6,495 ns/iter (+/- 52) = 1261 MB/s
test test_hashing_u8         ... bench:     851 ns/iter (+/- 16) = 1203 MB/s
test test_hashing_vec_of_u64 ... bench:   6,499 ns/iter (+/- 59) = 1260 MB/s
```
2016-01-27 16:25:36 +00:00
bors
8256c470a5 Auto merge of #31089 - fhahn:macro-ice, r=pnkfelix
This is a  work in progress PR that potentially should fix #29084, #28308, #25385, #28288, #31011. I think this may also adresse parts of  #2887.

The problem in this issues seems to be that when transcribing macro arguments, we just clone the argument Nonterminal, which still has to original spans. This leads to the unprintable spans. One solution would be to update the spans of the inserted argument to match the argument in the macro definition. So for [this testcase](https://github.com/rust-lang/rust/compare/master...fhahn:macro-ice?expand=1#diff-f7def7420c51621640707b6337726876R2) the error message would be displayed in the macro definition:

    src/test/compile-fail/issue-31011.rs:4:12: 4:22 error: attempted access of field `trace` on type `&T`, but no field with that name was found
    src/test/compile-fail/issue-31011.rs:4         if $ctx.trace {

Currently I've added a very simple `update_span` function, which updates the span of the outer-most expression of a `NtExpr`, but this `update_span` function should be updated to handle all Nonterminals. But I'm pretty new to the macro system and would like to check if this approach makes sense, before doing that.
2016-01-27 12:12:52 +00:00
Florian Hahn
ecb7b01a08 Add NOTE test annotations 2016-01-27 11:48:46 +01:00
Florian Hahn
e533ed91be Avoid storing interolated token in Parser.last_token 2016-01-27 11:28:33 +01:00
bors
b8b18aac12 Auto merge of #31206 - nrc:early-save, r=nikomatsakis
r? @nikomatsakis
2016-01-27 10:17:55 +00:00
Florian Hahn
47bfd8c93c Turn interpolated_or_expr_span into a function 2016-01-27 10:47:33 +01:00
bors
aba11b3206 Auto merge of #31020 - regexident:fix_16884, r=brson
Changes error message from displaying first found missing constructor witness to showing up to 10, if necessary.

Fixes issue #16884.
2016-01-27 07:32:00 +00:00
bors
a186eb2fb2 Auto merge of #30859 - aliclark:musl-nx-issue, r=brson
This explicitly adds an option telling the linker on these platforms to make the stack and heap non-executable (should already be the case for Windows, and likely OS X).

Without this option there is some risk of accidentally losing NX protection, as the linker will not enable NX if any of the binary's constituent objects don't contain the .note.GNU-stack header.

We're not aware of any users who would want a binary with executable stack or heap, but in future this could be made possible by passing a flag to disable the protection, which would also help document the fact to the crate's users.

Edit: older discussion of previous quickfix to add a .note.GNU-stack header to libunwind's assembly:

Short term solution for issue #30824 to ensure that object files generated from assembler contain the .note.GNU-stack header.

When this header is not present in any constituent object files, the linker refrains from making the stack NX in the final executable.

Further actions:

I'll try to get this change merged in with upstream too, and then update these instructions to just compile the fixed version.

It seems a good idea to use issue #30824 or some other issue to add a test that similar security regressions can be automatically caught in future.
2016-01-27 03:30:14 +00:00
Stepan Koltsov
641267e4c2 Allow #[repr(i32)] for univariant enum
```
#[repr(i32)]
enum Univariant {
    X = 17
}
```

Fixes #10292
2016-01-27 04:50:04 +03:00
bors
b694d1b1d1 Auto merge of #30487 - jonas-schievink:more-attrs-lint-fixes, r=alexcrichton
`LateContext` already does this, looks like this was just forgotten in #29850.

Found while investigating #30326 (but doesn't fix it)
2016-01-27 01:30:28 +00:00
Ulrik Sverdrup
aeb3aba951 collections: Use slices parts in PartialEq for VecDeque
This improves == for VecDeque by using the slice representation.

This will also improve further if codegen for slice comparison improves.

Benchmark run of 1000 u64 elements, comparing for equality (all equal).
Cpu time to compare the vecdeques is reduced to less than 50% of what it
was before.

```
test test_eq_u64       ... bench:  1,885 ns/iter (+/- 163) = 4244 MB/s
test test_eq_new_u64   ... bench:    802 ns/iter (+/- 100) = 9975 MB/s
```
2016-01-27 00:35:03 +01:00
Ulrik Sverdrup
d3174ce751 collections: Hash VecDeque in its slice parts
Use .as_slices() for a more efficient code path in VecDeque's Hash impl.

This still hashes the elements in the same order.

Before/after timing of VecDeque hashing 1024 elements of u8 and
u64 shows that the vecdeque now can match the Vec
(test_hashing_vec_of_u64 is the Vec run).

before

test test_hashing_u64        ... bench:  14,031 ns/iter (+/- 236) = 583 MB/s
test test_hashing_u8         ... bench:   7,887 ns/iter (+/- 65) = 129 MB/s
test test_hashing_vec_of_u64 ... bench:   6,578 ns/iter (+/- 76) = 1245 MB/s

after

running 5 tests
test test_hashing_u64        ... bench:   6,495 ns/iter (+/- 52) = 1261 MB/s
test test_hashing_u8         ... bench:     851 ns/iter (+/- 16) = 1203 MB/s
test test_hashing_vec_of_u64 ... bench:   6,499 ns/iter (+/- 59) = 1260 MB/s
2016-01-27 00:04:03 +01:00
Steve Klabnik
5c61be68d0 Mention that globs import public symbols
Fixes #30954
2016-01-26 17:47:01 -05:00
bors
4b615854f0 Auto merge of #31120 - alexcrichton:attribute-deny-warnings, r=brson
This commit removes the `-D warnings` flag being passed through the makefiles to
all crates to instead be a crate attribute. We want these attributes always
applied for all our standard builds, and this is more amenable to Cargo-based
builds as well.

Note that all `deny(warnings)` attributes are gated with a `cfg(stage0)`
attribute currently to match the same semantics we have today
2016-01-26 22:10:10 +00:00
Matt Brubeck
6ff177efea Add size hints for BTreeSet iterators 2016-01-26 14:09:56 -08:00
Alex Burka
2f633b2204 capitalization and associated types 2016-01-26 14:36:48 -05:00
bors
a9e139b66c Auto merge of #31081 - alexcrichton:stabilize-hasher, r=aturon
This commit implements the stabilization of the custom hasher support intended
for 1.7 but left out due to some last-minute questions that needed some
decisions. A summary of the actions done in this PR are:

Stable

* `std:#️⃣:BuildHasher`
* `BuildHasher::Hasher`
* `BuildHasher::build_hasher`
* `std:#️⃣:BuildHasherDefault`
* `HashMap::with_hasher`
* `HashMap::with_capacity_and_hasher`
* `HashSet::with_hasher`
* `HashSet::with_capacity_and_hasher`
* `std::collections::hash_map::RandomState`
* `RandomState::new`

Deprecated

* `std::collections::hash_state`
* `std::collections::hash_state::HashState` - this trait was also moved into
  `std::hash` with a reexport here to ensure that we can have a blanket impl to
  prevent immediate breakage on nightly. Note that this is unstable in both
  location.
* `HashMap::with_hash_state` - renamed
* `HashMap::with_capacity_and_hash_state` - renamed
* `HashSet::with_hash_state` - renamed
* `HashSet::with_capacity_and_hash_state` - renamed

Closes #27713
2016-01-26 19:30:54 +00:00