R CMD check has as part of its checks of compiled code a test that the
.so/.dll (and the ,o files if available) contains any
dangerous/non-portable entry points.  To detect these, the code in
src/library/tools/R/sotools.R contains a table of known mappings of
C/C++/Fortran function names to entry points.

These entries are specific to OS asd conpiler and are of the form

      "linux, Fortran, gfortran, open, _gfortran_st_open",

The langauge and compiler name are determined by configure and stored
in environment variable R_SYSTEM_ABI in etc/Renviron: however this is
read at R installation and cached in tools:::system_ABI .

Adding a new OS or compilers needs to be done in m4/R.m4 and
'configure' regenerated.  Note that as clang and Intel C/C++ compilers
identify themselves as GCC, they use the same tables as gcc/g++ but
should there be differences this needs alternative entries.

Package sotools_0.1.tar.gz in this directory will then help with the
mapping.  It containe C, C++ and Fortran code exercising most of the
problematic entry points.  This serves two purposes:

1) To check for changes to the known mappings, with compiler and/or
options upaate, e.g. adding FORTIFY flags (either by the user or the
compiler default as has happened with Apple clang).

2) To identify mappings for new platforms (it was written for
flang-new and Intel ifx).

Unpack and check the package, and look at

nm -g sotools/src/c.o
nm -g sotools/src/cxx.o
nm -g sotools/src/fort.o

especially the 'U' entries.  It is usually clear from their mapped
names what these refer to, but commenting out parts of the source files
and re-checking will make sure.

Sometimes a single C/C++/Fortran function will map to different entry
points depending on its arguments.  For example we have multiple
entries for Fortran stop.  The test package cannot be exhaustive, and
most of these were found by applying nm -g to the runtime libraries,
looking for the already detected entry point and seeing if there are
similar ones.  The extreme seen so far is flang-new's read and write,
which expand into multiple calls for different argument types.

Not all the test functions get mapped to visible entry points on all
platforms.

If static runtime libs are used (e.g. on Windows and currently with
flang-new), entry points from the library will get compiled into the
DSO/DLL and may be reported.  Normally the .o's are available and have
been analysed in symbols.rds at package installation, so this is
circomvented.