miri interpretation of large array initialization is slow

[oli-obk]

Right now, if you are initializing a large array either manually or with an array repeat expression takes a long time during interpretation.

• Fixing array repeat expressions requires us to stop filling each element individually and just manually filling up the virtual memory (https://github.com/rust-lang/rust/blob/master/src/librustc_mir/interpret/eval_context.rs#L591)

Arrays with lots of fields that are initialized as

static FOO: [T; N] = [A, B, C, ....., XX, XY];

are turned into the MIR equivalent of

static FOO: [T; N] = {
let array: [T; N] = mem::uninitialized();
let a = A;
let b = B;
let c = C;
....
let xx = XX;
let xy = XY;
array = [A, B, C, ...., XX, XY];
array
}

Which requires twice the memory (once for each variable and once for the array) and twice the instructions (initializing the variables and copying each variable into the array).

• Instead, we should turn that MIR into

static FOO: [T; N] = {
let array: [T; N] = mem::uninitialized();
array[0] = A;
array[1] = B;
array[2] = C;
....
array[N-2] = XX;
array[N-1] = XY;
array
}

What do you think @eddyb ?

cc @Zoxc @bob_twinkles @rkruppe

[eddyb]

@oli-obk That is part of removing Rvalue::Aggregate, which I want to do at some point.
The plan, wrt borrowck, is to have a SetDiscriminant(array, 0) to indicate the value is fully initialized.
Sadly, just doing the optimization after the fact is pretty expensive itself, see #48193.
cc @nikomatsakis