The R for Windows Build Process
===============================

from the point of view of a Unix installer of R.

Compilation of C/Fortran code is done in two pathways.

1) standard and add-on packages, the most similar to Unix.

The primary Makefiles are
$(R_HOME)/etc${R_ARCH}/Makeconf
share/make/winshlib.mk

included in that order.  Some settings in Makeconf are substituted in
etc/Makeconf by fixed/Makefile, taken from MkRules.


2) Everything else, where the primary Makefile is MkRules which is
where all the customization is done.  This is included by all
Makefile.win files in directories above this one and

./Makefile
./fixed/Makefile
./front-ends/Makefile
./getline/Makefile
./installer/Makefile

and replaces Unix's top-level Makeconf.


The largest difference from Unix (even a R-shlib build) is the use of
DLLs, which require the exported symbols to be listed (via nm) in a
.def file and fed to the compiler with the object files for linking.

In recent years DLLs are linked to directly as libraries, but there
remains provision for import libraries via lib%.dll.a: %.def rules.

Making executables has a number of Windows-specific features, done in
front-ends/Makefile:

- A resource compiler is used to compile in version information, an
  icon and a manifest.  Also done for version information in all the
  other DLLs under bin and modules (R.dll Rblas.dll Rgraphapp.dll
  Riconv.dll Rlapack.dll lapack.dll).

- LINKFLAGS includes flags for the stack size.

A resource compiler is used to add version information to the DLLs
under directories bin and modules.

The default is to compile without debug info: this can be enabled by
using 'make DEBUG=T' from this directory, or install add-on packages
with Rcmd INSTALL --debug.  Otherwise DLLs and executables are
stripped.


Link-Time Optimization
======================

To enable LTO for building R set the LTO macro in MkRules.local, to
-flto or e.g. -flto=8 to use 8 threads.

Checking of packages with LTO can be performed by setting the LTO_OPT
macro to -flto in MkRules.local and using Rcmd INSTALL --use-LTO.

For an installed version of R it should suffice to edit the value of
LTO_OPT in the etc/*/Makeconf files or to set it in a personal or site
Makevars file.

[Unlike a Unix-alike, LTO/LTO_OPT are used for Fortran as well as C/C++.]


Cross-compilation
=================

Versions of R prior to 4.2.0 could be cross-compiled using the tools
provided by Linux distributions including Fedora, Debian and Ubuntu.
However, these do not (at the time of writing) support UCRT-based builds.

https://cran.r-project.org/bin/windows/base/howto-R-devel.html
describes how to obtain a suitable cross-compilation toolchain for
x86_64 Linux (based on glibc).  Look at the section entitled something
like

'Setting up MXE build from pre-built tarballs',

and follow the instructions, which install the toolchain under a place
it (and we) call MXE_ROOT.  (To build R only the
'rtools44-toolchain-libs-base' version is required.)

You will also need to fetch the pre-built Tcl/Tk as described in the
section 'Building R from source using a toolchain tarball'.  The default
location for the latter is R_HOME/Tcl.

To build all the compiled code, edit MkRules.local to something like

MXE_ROOT = wherever you put it, or /usr/lib/mxe (which was set as a symlink)
BINPREF64 = $(MXE_ROOT)/usr/bin/x86_64-w64-mingw32.static.posix-
EXT_LIBS = $(MXE_ROOT)/usr/x86_64-w64-mingw32.static.posix
#CURL_CA_BUNDLE = /etc/pki/tls/certs/ca-bundle.crt
TEXI2ANY=/usr/bin/texi2any

Setting LTO is supported.

Then in this directory

make MkRules rbuild rpackages-cross cairodevices

When targeting aarch64 Windows (rather than x86_64), use toolchain bundles
with "aarch64" in their name, such as 'rtools44-toolchain-libs-base-aarch64'
and 'rtools44-toolchain-libs-cross-aarch64', and Tcl bundle 'tcltk-aarch64'.
The cross-compilers run again on x86_64 Linux (based on glibc), such as when
targeting x86_64 Windows.

For aarch64, use MkRules.local such as

MXE_ROOT = wherever you put it, or /usr/lib/mxe (which was set as a symlink)
USE_LLVM = 1
WIN =
BINPREF64 = $(MXE_ROOT)/usr_aarch64/bin/aarch64-w64-mingw32.static.posix-
EXT_LIBS = $(MXE_ROOT)/usr_aarch64/aarch64-w64-mingw32.static.posix
TEXI2ANY = /usr/bin/texi2any

Cross-building packages
=======================

There is experimental minimal support for cross-building packages.

Copy {bin,etc}/x64 from this build to a standard Linux build of R.

Edit the copy of etc/x64/Makeconf to have

R_WIN = /path/to/top/directory/of/this/build
R_XTRA_CPPFLAGS = -I"$(R_WIN)/include" -DNDEBUG

Set the environment variable R_CROSS_BUILD to x64.

Use R CMD INSTALL as usual. (This does not do a staged install nor
test loading.)  --use-LTO is supported if LTO_OPT was set.  Use a
separate library tree (-l) as these are Windows and not Linux
binaries.

R CMD INSTALL --build will produce a zipped installation.

The newly installed packages must not be visible to later builds, because
they are not Linux binaries, so cannot be loaded when they are needed as
dependencies.  You can use separate library for each package to achieve
this, or always move away the newly installed package.

Should a package require external libraries, these can be placed under
LOCAL_SOFT as defined in etc/x64/Makeconf in the copy.

Some packages use pkg-config to query C flags or libraries to link and
unconditionally use "pkg-config" from PATH.  For such packages one has to
arrange for "pkg-config" on PATH to call to the appropriate pkg-config
wrapper for the target platform and toolchain.  With Rtools, it is
"x86_64-w64-mingw32.static.posix-pkg-config".  This is not needed for
building R itself, R uses the wrapper directly.

When targeting aarch64 Windows, copy etc/Makeconf from the cross-build
(R_WIN) over etc/Makeconf of the linux build and edit the copy to have the
R_XTRA_CPPFLAGS, pointing to the cross-build, as above.  Copy bin/*.dll from
the cross-build to bin/ in the linux build.  Set R_CROSS_BUILD to
"singlearch".

Cross-building the aarch64 installer
====================================

One can cross-compile binaries of R and recommended packages as above and
then, on Windows/x86_64, build an installer for Windows/aarch64 using these.

First, build a native x86_64 build of R on Windows, including
"cairodevices", "recommended", "vignettes" and "manuals". This is all done
automatically when building the installer ("distribution") for x86_64.
However, such installer has to be copied away because it would be ovewritten
in the next step.

Then run

make rinstaller CROSS_BUILD=<cross-compiled-binaries>

the tree with cross-compiled-binaries must include:

Tcl (the full Tcl bundle for aarch64)
library/*/libs/*.dll
modules/*.dll
bin/*.dll
bin/*.exe,
bin/config.sh
etc/Makeconf 

Recommended packages must be placed under library, together with the base
packages.

The version of R and recommended packages must be identical on the Linux and
the Windows host.

