illumos gate

OmniOS bloody, as of 20220127, is now being built with gcc 10.
#14422 has also been pulled into that.

The approach I took for testing gcc10 as a primary compiler was initially to compare the generated artefacts from gcc7 and gcc10, and then move on to a system booted with gcc10 bits and running various tests.

I began with some very broad checks - comparing the sizes of the .SUNW_ctf sections, and comparing which functions were present in each object, and their sizes, and then working to understand the differences.

With CTF, it quickly became apparent that there was a significant difference in the kernel. In particular, there was a lot less CTF data in genunix and more in the other kernel modules. The reason for this is that gc10 defaults eliminate-unused-debug-symbols to on. This means that, when using gcc10 as the primary compiler, symbols are stripped from the genunix object, leaving less there for the subsequent CTF uniquification step. As a result, symbols which are used by several modules end up being duplicated in each module instead of held once within genunix.

This was addressed as #14255 by adding -fno-eliminate-unused-debug-symbols and -fno-eliminate-unused-debug-types for the genunix build to support continued module uniquification. This is not done for the other objects, and results in a general reduction in the CTF section size across the board, with unused objects being removed. As an example, the __FILE struct is in pretty much every object with gcc7, and only in those that use it with gcc10.

Next, looking at functions that had changed size significantly led to discovering that gcc10 uses different thresholds in its heuristics for inlining functions; several functions marked explicitly with inline were not being inlined. The was also the case for some with gcc7, but gcc10 was inlining even fewer.
I went through and cleaned up the few functions that can never be inlined for various reasons, enabled the compiler's warning option that will report when a function is not inlined, and explicitly specified the function size limit to get more consistent behaviour between the gcc versions. The warning part was only applied to usr/src/uts as the userland components pull in unbundled libraries (such as openssl) which triggered them. This change means that if you mark a function in the kernel as inline but the compiler chooses not to inline it, then it's a fatal error unless you override that in the respective Makefile (this has been in gate for a year now). The key part of this change in relation to gcc10 was explicitly specifying the inline thresholds, as they were significantly different between gcc7 and 10.
#14282

Comparing the functions/symbols in each generated artefact showed that gcc10 was adding additional .cold symbols, such as kmem_error.cold. This was addressed by enabling the -_gcc=-fno-reorder-blocks-and-partition option. This was done for both gcc7 and gcc10 and eliminated these extra symbols from being generated.
#14417

A final noted difference is that gcc10 is no longer removing unused static functions from objects, which results in bonus unecessary functions being left in artefacts. I did some specific cleanup in #14422 to reduce this, mostly by moving functions properly to within DEBUG and SPARC guards so they don't appear in the output but there are still some extra functions in the gcc10 artefacts.
I experimented with different compiler options and found that enabling -ftoplevel-reorder caused these functions to be removed. However, it also, as you might expect, re-orders functions, and also employs constant folding on static global variables which are only read. This effectively removes a lot of historic tuneables. Anything intended to be a tuneable should not, of course, be static, but many of the things affected here seem to be superficially useful (nfs4_max_threads for example). They are enumerated in the following issue. In the end, -ftoplevel-reorder was not applied and there are 297 additional functions in the non-DEBUG gcc10 build artefacts (fewer with DEBUG as many of these are functions used only in DEBUG builds).
#14749

Having got the gcc10 output closer to gcc7, I moved onto broader testing. The various test suites were run with matching output, the list of fbt probes was compared between the builds - there were new functions as described above, but nothing has been lost. Spot checks were performed on the fbt probe location in functions to ensure they are placed before any branches. These are basically the checks recommended in IPD7.

OmniOS has shipped the last two stable releases with a gcc10 primary and only one regression has been found in that time - #14948 - which increases confidence.