Another case of "Be extra careful with `auto` in the Eigen library." - c++

Question

EDIT: The title was
How do eigen expressions and link-time-optimization interact
But this issue has nothing to do with lto.
I just introduced and then fixed the following bug:
Eigen::Vector4d some_function(double arg) {
Eigen::Matrix4d mat;
mat << 2,2,3,4,5,6,7,8,9,10,11,2,13,14,15,16;
Eigen::Vector4d spline_constraints(a(arg),b(arg),c,d);
auto coefficients = mat.lu().solve(spline_constraints);
return coefficients;
}
This is pseudocode. In actuality both the function and the matrix are static members of a class and a(double arg) and b(double arg) are also static member functions.
I hope it is suffcient. If not, I will try to cook up a minimal working example.
The behaviour is very compiler dependent:
GCC
When I compile it into a static library and link the library elsewhere, it SEEMS to work fine, regardless of debug build or release build (i.e. with non-lto optimizations).
If I compile and link it with link time optimization, it compiles and links fine and the runtime behaves in a wrong way:
With gcc a sparse matrix of size 1350x1350, whose construction depends on the code above is claimed to be non-decomposible with the lu decomposition (without lto it doesn't claim so, although I'm not sure, the decomposition is correct in that case).
Clang
In release build with or without lto I get a segmentation fault.
The debug build works fine.
Fix
The code is fixed by with one of the following:
Eigen::Vector4d some_function() {
Eigen::Matrix4d mat;
mat << 2,2,3,4,5,6,7,8,9,10,11,2,13,14,15,16;
Eigen::Vector4d spline_constraints(a,b,c,d);
auto coefficients = mat.lu().solve(spline_constraints).eval();
return coefficients;
}
that is by adding .eval()
or
Eigen::Vector4d some_function() {
Eigen::Matrix4d mat;
mat << 2,2,3,4,5,6,7,8,9,10,11,2,13,14,15,16;
Eigen::Vector4d spline_constraints(a,b,c,d);
return mat.lu().solve(spline_constraints);
}
that is, by returning the expression itself.
My question is: What exactly happened here?
Related (would be nice to know, not really part of the question): Is there a compiler warning or other feature that could prevent me from making this mistake in the future?
Also (likewise): Is there some part of the Eigen docs, that would have warned me of this, had I found it before?
My impression from the docs was, that failing to add .eval() somewhere could result in decreased performance but not in undefined behaviour.
EDIT: I was wrong: The docs state that wrong application of eval() can lead to segfaults:
Eigen docs on eval()