https://gcc.gnu.org/bugzilla/show_bug.cgi?id=115345
Bug ID: 115345
Summary: [12/13/14 REGRESSION] / Different outputs compared to
GCC 11- and MSVC/Clang
Product: gcc
Version: 12.0
Status: UNCONFIRMED
Severity: normal
Priority: P3
Component: c
Assignee: unassigned at gcc dot gnu.org
Reporter: djordje.baljozovic at ac dot rwth-aachen.de
Target Milestone: ---
Created attachment 58344
--> https://gcc.gnu.org/bugzilla/attachment.cgi?id=58344&action=edit
Crash report
Our team works on a large code base written primarily in C:
https://github.com/IUPAC-InChI/InChI .
After compiling the project with MSVC, GCC and Clang/LLVM, we noticed that
there are discrepancies in outputs when the project is compiled with GCC
versions 14.0-14.1/13.0-13.3/12.0-12.4 -- in short GCC versions 12+.
The issue occurs when the GCC 12+ compiled project cannot process 10 specific
inputs (.sdf/.mol files) which are processed without any problems with GCC
11-/MSVC/Clang.
After running dbg with one of these inputs, we got a crash report which I am
attaching to this issue (file name: inchi_stacktrace_core_dump.txt).
We had put some "control" code in strutil.c which creates an output file
(gcc_crash_report.txt) with relevant values of all variables within this
function:
...
#if (GCC_DEBUG)
FILE* gcc_fptr;
gcc_fptr = fopen("gcc_crash_report.txt", "w");
if (!gcc_fptr)
{
printf("\n>>>>>Error opening gcc_crash_report.txt file!<<<<<\n");
}
#endif
for (j = 0; j < num_at; j++)
{
if (!nNewCompNumber[j])
{
/* mark starting with at[j] */
int fst_at = 0, nxt_at = 0, cur_at = j;
num_components++;
/* first time at at[j] */
fst_at = cur_at;
nNewCompNumber[fst_at] = (AT_NUMB) num_components;
bool cur_neq_fst = true;
/* find next neighbor */
do
{
#if (GCC_DEBUG)
fprintf(gcc_fptr, "\ncur_at = %d, nxt_at = %d, iNeigh[cur_at] =
%d, at[cur_at].val = %d ", cur_at, nxt_at, iNeigh[cur_at], at[cur_at].valence);
#endif
if (iNeigh[cur_at] < at[cur_at].valence)
{
int ineigh_incr = (int)iNeigh[cur_at];
nxt_at = at[cur_at].neighbor[ineigh_incr];
iNeigh[cur_at]++;
#if (GCC_DEBUG)
fprintf(gcc_fptr, "/ ineigh_incr = %d, new_nxt_at = %d,
iNeigh[cur_at]_inc = %d, nNewCompNumber[nxt_at] = %d ", ineigh_incr, nxt_at,
iNeigh[cur_at], nNewCompNumber[nxt_at]);
#endif
if (!nNewCompNumber[nxt_at])
{
/* forward edge: found new atom */
nNewCompNumber[nxt_at] = (AT_NUMB) num_components;
nPrevAtom[nxt_at] = (AT_NUMB) cur_at;
cur_at = nxt_at;
}
}
else if (cur_at == fst_at)
{
cur_neq_fst = false;
/* break; done */
}
else
{
cur_at = nPrevAtom[cur_at]; /* retract */
}
} while (cur_neq_fst);
#if (GCC_DEBUG)
fprintf(gcc_fptr, "\n");
#endif
}
}
#if (GCC_DEBUG)
if (gcc_fptr)
{
fclose(gcc_fptr);
}
#endif
...
MSVC, Clang and GCC 11- compiled project and GCC 12+ compiled project produce
totally different gcc_crash_report.txt contents for the same input .mol/.sdf
file.
This example shows that the variables in question get totally different values
when compiled with GCC 12+, or, in some cases, do not get values at all.
The described issue seems to be indicating an existence of a very serious bug,
which needs to be fixed immediately.
At this moment, we are recommending our users to compile the code from the
source using GCC 11- or MSVC/Clang, but this is obviously not a solution.
I can give some examples but only one attachment is allowed here.
Please feel free to let me know if any further
Thank you in advance for your assistance.
George
