Issue 1:
I noticed earlier that the compile time of image increased massively during the beginning of 2015. Unfortunately it was hard to quantify this regression since we also changed a lot during this time.

Fortunately I just found a good example that shows a 20-fold increase in compile time. It is a single file with no other dependencies (if somebody wants to try: the original version is even much older). The two revisions are exactly the same code, the newer just has been updated to compile on a recent rustc. Note that this is rustc only, no time is spend in llvm.

$ sudo rustc --version
rustc 0.13.0-nightly (7608dbad6 2014-12-31 10:06:21 -0800)
$ time sudo rustc --crate-type=lib -Z no-trans inflate.rs

real 0m1.176s
user 0m1.059s
sys 0m0.113s

(note that something is wrong with the old .pkg-file I used to install rustc, I need to use sudo to run it)

$ rustc --version
rustc 1.1.0-nightly (c4b23aec4 2015-04-29) (built 2015-04-28)
$ time rustc --crate-type=lib -Z no-trans inflate.rs

real 0m25.208s
user 0m23.919s
sys 0m1.213s

The time profiles show that driver::phase_1_parse_input and driver::phase_2_configure_and_expand almost stayed constant while the time spent in driver::phase_3_run_analysis_passes exploded.

Issue 2:
This simple program takes ~1minute to compile:

macro_rules! f0( () => (1) );
macro_rules! f1( () => ({(f0!()) + (f0!())}) );
macro_rules! f2( () => ({(f1!()) + (f1!())}) );
macro_rules! f3( () => ({(f2!()) + (f2!())}) );
macro_rules! f4( () => ({(f3!()) + (f3!())}) );
macro_rules! f5( () => ({(f4!()) + (f4!())}) );
macro_rules! f6( () => ({(f5!()) + (f5!())}) );
macro_rules! f7( () => ({(f6!()) + (f6!())}) );
macro_rules! f8( () => ({(f7!()) + (f7!())}) );
macro_rules! f9( () => ({(f8!()) + (f8!())}) );
macro_rules! f10( () => ({(f9!()) + (f9!())}) );
macro_rules! f11( () => ({(f10!()) + (f10!())}) );
fn main() {
f10!();
}

The output of -Z time-passes looks like:

time: 0.000 parsing
time: 0.000 recursion limit
time: 0.000 gated macro checking
time: 0.000 configuration 1
time: 0.000 crate injection
time: 0.012 macro loading
time: 0.000 plugin loading
time: 0.000 plugin registration
time: 0.032 expansion
time: 0.000 complete gated feature checking 1
time: 0.002 configuration 2
time: 0.001 maybe building test harness
time: 0.001 prelude injection
time: 0.000 checking that all macro invocations are gone
time: 0.000 complete gated feature checking 2
time: 0.001 assigning node ids and indexing ast
time: 0.000 external crate/lib resolution
time: 0.000 language item collection
time: 0.001 resolution
time: 0.000 lifetime resolution
time: 0.000 looking for entry point
time: 0.000 looking for plugin registrar
time: 0.001 region resolution
time: 0.000 loop checking
time: 0.000 static item recursion checking
time: 0.000 type collecting
time: 0.000 variance inference
time: 0.169 coherence checking
time: 55.344 type checking
time: 0.009 const checking
time: 0.000 privacy checking
time: 0.000 stability index
time: 0.000 intrinsic checking
time: 0.000 effect checking
time: 0.000 match checking
time: 0.000 liveness checking
time: 0.023 borrow checking
time: 0.010 rvalue checking
time: 0.000 reachability checking
time: 0.000 death checking
time: 0.000 stability checking
time: 0.000 unused lib feature checking
time: 0.004 lint checking
time: 0.000 resolving dependency formats
time: 0.002 translation
time: 0.000 llvm function passes
time: 0.000 llvm module passes
time: 0.002 codegen passes
time: 0.000 codegen passes
time: 0.007 LLVM passes
time: 0.242 running linker
time: 0.243 linking

And profiling using OSX looks like:

cc @pnkfelix, @nikomatsakis

This was discovered in updating cargo with a rustc from 3/26 to 4/2, so it looks like it may be a recent regression?