gronod/lfs
1
0
Fork 0
mirror of https://git.linuxfromscratch.org/lfs.git synced 2025-06-18 19:29:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

gcc: Don't decrease the stack limit

Browse Source 
I've had doubts on this "ulimit -s 32768" command for years.  After
reading GCC code (libiberty/stack-limit.c) I'm pretty sure this command
is not doing what we expected.

In a typical Linux distro, the default "soft" stack limit is 8 MiB and
the default "hard" stack limit is infinite.  And GCC will automatically
increase the soft limit to 64 MiB if the original soft limit is smaller
than 64 MiB, and the hard limit is at least 64 MiB.  So with a typical
default configuration, the real stack limit of GCC is 64 MiB.

But our "ulimit -s 32768" command sets both the soft limit and the hard
limit to 32 MiB.  Thus we are actually *decreasing* the real stack
limit.  Fortunately this has not caused any test failures, but it's just
wrong (contradicting with the explanation of the command).

Thus just raise the hard limit to infinite in case the host distro uses
a not so typical configuration where the hard limit is tight, and let
GCC to set up the soft limit to the expected value on its own.  It's
more future-proof than "ulimit -s 65536" in case GCC changes the
expected stack limit in the future.

It should be safe to make the change in freeze because in jhalfs it only
affects the test suite, and even in a manual build the user can skip
this command if not running the GCC test suite.
This commit is contained in:
Xi Ruoyao 2024-08-27 16:37:07 +08:00
parent 68c63ae3af
commit 2ca7fca799
No known key found for this signature in database
GPG Key ID: ACAAD20E19E710E3
1 changed files with 9 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
chapter08/gcc.xml
View File

@ -139,10 +139,16 @@ cd build</userinput></screen>
command below, where x is the number of CPU cores on your system.</para>
</important>
<para>One set of tests in the GCC test suite is known to exhaust the default
stack, so increase the stack size prior to running the tests:</para>
<para>GCC may need more stack space compiling some extremely complex
code patterns. As a precaution for the host distros with a tight stack
limit, explicitly set the stack size hard limit to infinite.
On most host distros (and the final LFS system) the hard limit is
infinite by default, but there's no harm to set it explicitly anyway.
It's not needed to change the stack size soft limit because GCC will
automatically set it to an appropriate value, as long as the value does
not exceed the hard limit:</para>
<screen><userinput remap="test">ulimit -s 32768</userinput></screen>
<screen><userinput remap="test">ulimit -s -H unlimited</userinput></screen>
<para>Now remove/fix several known test failures:</para>