Clang takes very long time to compile LLVM IR large arrays - clang

Question

I am trying to compile LLVM IR code that contains a few large arrays (400 elements). When I try to compile this with clang (not run, just compile) - it takes longer than 10 minutes.
IR Code
define i32 #main() {
%j = alloca double
%i = alloca double
%foo = alloca [400 x double]
%B = alloca [400 x [400 x double]]
%A = alloca [400 x [400 x double]]
%1 = insertvalue [400 x double] undef, double 0.000000e+00, 0
%2 = insertvalue [400 x [400 x double]] undef, [400 x double] %1, 0
store [400 x [400 x double]] %2, [400 x [400 x double]]* %A
%3 = insertvalue [400 x double] undef, double 0.000000e+00, 0
%4 = insertvalue [400 x double] undef, double 0.000000e+00, 0
%5 = insertvalue [400 x [400 x double]] undef, [400 x double] %4, 0
store [400 x [400 x double]] %5, [400 x [400 x double]]* %B
%6 = insertvalue [400 x double] undef, double 0.000000e+00, 0
store [400 x double] %6, [400 x double]* %foo
store double 0.000000e+00, double* %i
ret i32 0
}
Command to run: clang out.ll -o built
Edit
I think this has to do with clang trying to create the arrays or something. As I make bigger arrays, clang builds take longer but, running the programs takes about the same amount of time. It does not really make sense to me why this would happen but, it does appear to be what is happening.
Versions
LLVM: Apple LLVM version 9.0.0 (clang-900.0.39.2)
Clang: clang version 6.0.0 (tags/RELEASE_600/final)
(added from comments)
How do I make this take less time? ... It seems weird that it would take this long. I know there is a way to make it take less time because, for example, C is able to make arrays that big and it will compile in no time.
Edit 2
I tried implementing malloc in order to have the arrays allocated on the heap instead of the stack. Here is some new IR Code. My question is where is this being allocated? When I generate multidimensional arrays it is still really slow - in that case how would I speed it up again?
%foo = alloca [400 x [400 x double]]
%calltmp1 = call i8* #malloc(i64 10240000)
%4 = bitcast i8* %calltmp1 to [400 x [400 x double]]*
%5 = getelementptr [400 x [400 x double]], [400 x [400 x double]]* %4, i32 0, i32 0
%calltmp2 = call i8* #malloc(i64 25600)
%6 = bitcast i8* %calltmp2 to [400 x double]*
%7 = getelementptr [400 x double], [400 x double]* %6, i32 0, i32 0
store double 1.000000e+00, double* %7
%8 = getelementptr [400 x double], [400 x double]* %6, i32 0, i32 1
store double 1.000000e+00, double* %8
%9 = getelementptr [400 x double], [400 x double]* %6, i32 0, i32 1
store double 1.000000e+00, double* %9
%initialized_array3 = load [400 x double], [400 x double]* %6
store [400 x double] %initialized_array3, [400 x double]* %5
%initialized_array4 = load [400 x [400 x double]], [400 x [400 x double]]* %4
store [400 x [400 x double]] %initialized_array4, [400 x [400 x double]]* %foo
Edit 3
Sorry for all the edits but, I think the extra info is helpful.
Here is some more IR Code I generated:
%foo = alloca [400 x [400 x double]]
store [400 x [400 x double]] undef, [400 x [400 x double]]* %foo
%0 = getelementptr [400 x [400 x double]], [400 x [400 x double]]* %foo, i32 0, i32 0
%1 = getelementptr [400 x double], [400 x double]* %0, i32 0, i32 0
store double 1.598000e+03, double* %1
This is almost identical to this IR Code generated form c:
%1 = alloca [400 x [400 x i32]], align 16
%2 = alloca i32*, align 8
%3 = getelementptr inbounds [400 x [400 x i32]], [400 x [400 x i32]]* %1, i64 0, i64 0
%4 = getelementptr inbounds [400 x i32], [400 x i32]* %3, i64 0, i64 0
store i32 1, i32* %4, align 16
However, the c code compiles in less than a second and mine takes too long to even be able to tell. This is because of line 2 in the first code snippet (below for reference). Why does that cause clang to run so slowly?
Line slowing it down:
store [400 x [400 x double]] undef, [400 x [400 x double]]* %foo