Fortran 中 -O2 的分段错误

Question

While developing a large Fortran software I have now and again come across this error, in particular when compiling with -O2 to have a bit better performance.

In some cases the error is real and can be corrected but in other cases I find no error and assume it is caused by -O2 shuffling around the code. As my old fashioned debugging technique is to add write statements close to the point where the error occurs have I found the error often disappeared when I did that.

Maybe because the -O2 optimization is a bit careful shuffling around such statements.

Recently I had this error in a loop which was not very complex and not very time critical and adding a write statement inside the loop prevented this error. When I removed the write statement the error came back. To avoid creating a lot of meaningless output while running the program I found it was sufficient to write to an internal character so for a user nothing changed.

There was no error when compiling the code without -O2 but the loop is inside a module using many local variables and I do not know how to compile one subroutine in a module separately without -O2.

I am using GNU Fortran 7.2.0 on Linux and Windows (this recent error occurred only on Linux but previously I have had similar problems with Windows). I do not have access to any other compilers but my code is free and has been compiled with other compilers with no problems reported.

So my question is if one can turn off -O2 for a small part of the code inside a module or if there are better alternatives than adding write statements to prevent -O2 to shuffle around the code inside a particular subroutine.

Answer 1

I arrived here via a web search, and in case it helps anyone, I want to share the solution in my case. Many commenters have mentioned the possibility of uninitialized variables. I had no such warning in my code, but I produced an apparently identical effect by allocating storage in a subroutine in such a way that the compiler presumably did not realize that freshly allocated memory was about to be used in the next line.

I did this by accidentally including an allocatable array in a module and then also passing it as an argument to a subroutine that first did the allocation (using the name in the module) and immediately thereafter started assigning values to array elements using the name that I had passed in as an argument. When I moved from -O1 to -O2, it stopped working. Rather than detecting the problem, -fcheck=bounds actually caused the code to run without the segfault.

I located the offending line by using -O2 -g -traceback without checking bounds. When I started referring to the array consistently using the name that I had passed as an argument, the problem went away.