{

echo Setting up directories for build

mkdir -p "$__RootBinDir"

mkdir -p "$__BinDir"

mkdir -p "$__LogsDir"

mkdir -p "$__MsbuildDebugLogsDir"

mkdir -p "$__IntermediatesDir"

if [ $__CrossBuild == 1 ]; then

mkdir -p "$__CrossComponentBinDir"

fi

{

echo "Checking prerequisites..."

# Check presence of CMake on the path

hash cmake 2>/dev/null || { echo >&2 "Please install cmake before running this script"; exit 1; }

function version { echo "$@" | awk -F. '{ printf("%d%02d%02d\n", $1,$2,$3); }'; }

local cmake_version=$(cmake --version | grep -Eo "[0-9]+\.[0-9]+\.[0-9]+")

if [[ $(version $cmake_version) -lt $(version 3.14.0) ]]; then

echo "Please install CMake 3.14 or newer from http://www.cmake.org/download/ or https://apt.kitware.com and ensure it is on your path."; exit 1;

fi

# Minimum required version of clang is version 4.0 for arm/armel cross build

if [[ $__CrossBuild == 1 && $__GccBuild == 0 && ("$__BuildArch" == "arm" || "$__BuildArch" == "armel") ]]; then

if ! [[ "$__ClangMajorVersion" -ge "4" ]]; then

echo "Please install clang4.0 or latest for arm/armel cross build"; exit 1;

fi

fi

# Check for clang

if [[ $__GccBuild == 0 ]]; then

__ClangCombinedDottedVersion=$__ClangMajorVersion;

if [[ "$__ClangMinorVersion" != "" ]]; then

__ClangCombinedDottedVersion=$__ClangCombinedDottedVersion.$__ClangMinorVersion

fi

hash clang-$__ClangCombinedDottedVersion 2>/dev/null || hash clang$__ClangMajorVersion$__ClangMinorVersion 2>/dev/null || hash clang 2>/dev/null || { echo >&2 "Please install clang-$__ClangMajorVersion.$__ClangMinorVersion before running this script"; exit 1; }

else

__GccCombinedDottedVersion=$__GccMajorVersion;

if [[ "$__GccMinorVersion" != "" ]]; then

__GccCombinedDottedVersion=$__GccCombinedDottedVersion.$__GccMinorVersion

fi

hash gcc-$__GccCombinedDottedVersion 2>/dev/null || hash gcc$__GccMajorVersion$__GccMinorVersion 2>/dev/null || hash gcc 2>/dev/null || { echo >&2 "Please install gcc-$__GccMajorVersion.$__GccMinorVersion before running this script"; exit 1; }

fi

{

local OptDataProjectFilePath="$__ProjectRoot/src/.nuget/optdata/optdata.csproj"

if [[ ( $__SkipRestoreOptData == 0 ) && ( $__isMSBuildOnNETCoreSupported == 1 ) ]]; then

echo "Restoring the OptimizationData package"

"$__RepoRootDir/eng/common/msbuild.sh" $__ArcadeScriptArgs \

$OptDataProjectFilePath /t:Restore /m \

$__CommonMSBuildArgs $__UnprocessedBuildArgs

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to restore the optimization data package."

exit $exit_code

fi

fi

if [ $__isMSBuildOnNETCoreSupported == 1 ]; then

# Parse the optdata package versions out of msbuild so that we can pass them on to CMake

local PgoDataPackagePathOutputFile="${__IntermediatesDir}/optdatapath.txt"

local IbcDataPackagePathOutputFile="${__IntermediatesDir}/ibcoptdatapath.txt"

# Writes into ${PgoDataPackagePathOutputFile}

"$__RepoRootDir/eng/common/msbuild.sh" $__ArcadeScriptArgs $OptDataProjectFilePath /t:DumpPgoDataPackagePath ${__CommonMSBuildArgs} /p:PgoDataPackagePathOutputFile=${PgoDataPackagePathOutputFile} 2>&1 > /dev/null

local exit_code=$?

if [ $exit_code != 0 ] || [ ! -f "${PgoDataPackagePathOutputFile}" ]; then

echo "${__ErrMsgPrefix}Failed to get PGO data package path."

exit $exit_code

fi

__PgoOptDataPath=$(<"${PgoDataPackagePathOutputFile}")

# Writes into ${IbcDataPackagePathOutputFile}

"$__RepoRootDir/eng/common/msbuild.sh" $__ArcadeScriptArgs $OptDataProjectFilePath /t:DumpIbcDataPackagePath ${__CommonMSBuildArgs} /p:IbcDataPackagePathOutputFile=${IbcDataPackagePathOutputFile} 2>&1 > /dev/null

local exit_code=$?

if [ $exit_code != 0 ] || [ ! -f "${IbcDataPackagePathOutputFile}" ]; then

echo "${__ErrMsgPrefix}Failed to get IBC data package path."

exit $exit_code

fi

__IbcOptDataPath=$(<"${IbcDataPackagePathOutputFile}")

fi

{

__OutputEventingDir=$1

__PythonWarningFlags="-Wall"

if [[ $__IgnoreWarnings == 0 ]]; then

__PythonWarningFlags="$__PythonWarningFlags -Werror"

fi

echo "Laying out dynamically generated EventSource classes"

$PYTHON -B $__PythonWarningFlags "$__ProjectRoot/src/scripts/genRuntimeEventSources.py" --man "$__ProjectRoot/src/vm/ClrEtwAll.man" --intermediate "$__OutputEventingDir"

{

# Event Logging Infrastructure

if [[ $__SkipMSCorLib == 0 ]]; then

generate_event_logging_sources "$__ArtifactsIntermediatesDir/Eventing/$__BuildArch/$__BuildType"

fi

{

skipCondition=$1

platformArch="$2"

intermediatesForBuild="$3"

extraCmakeArguments="$4"

message="$5"

if [ $skipCondition == 1 ]; then

echo "Skipping $message build."

return

fi

# All set to commence the build

echo "Commencing build of $message for $__BuildOS.$__BuildArch.$__BuildType in $intermediatesForBuild"

generator=""

buildTool="make"

if [ $__UseNinja == 1 ]; then

generator="ninja"

if ! buildTool=$(command -v ninja || command -v ninja-build); then

echo "Unable to locate ninja!" 1>&2

exit 1

fi

fi

if [ $__SkipConfigure == 0 ]; then

# if msbuild is not supported, then set __SkipGenerateVersion to 1

if [ $__isMSBuildOnNETCoreSupported == 0 ]; then __SkipGenerateVersion=1; fi

# Drop version.c file

__versionSourceFile="$intermediatesForBuild/version.c"

if [ $__SkipGenerateVersion == 0 ]; then

pwd

"$__RepoRootDir/eng/common/msbuild.sh" $__ArcadeScriptArgs $__RepoRootDir/eng/empty.csproj \

/p:NativeVersionFile=$__versionSourceFile \

/t:GenerateNativeVersionFile /restore \

$__CommonMSBuildArgs $__UnprocessedBuildArgs

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to generate native version file."

exit $exit_code

fi

else

# Generate the dummy version.c, but only if it didn't exist to make sure we don't trigger unnecessary rebuild

__versionSourceLine="static char sccsid[] __attribute__((used)) = \"@(#)No version information produced\";"

if [ -e $__versionSourceFile ]; then

read existingVersionSourceLine < $__versionSourceFile

fi

if [ "$__versionSourceLine" != "$existingVersionSourceLine" ]; then

echo $__versionSourceLine > $__versionSourceFile

fi

fi

# Regenerate the CMake solution

scriptDir="$__ProjectRoot/src/pal/tools"

if [[ $__GccBuild == 0 ]]; then

echo "Invoking \"$scriptDir/find-clang.sh\" $__ClangMajorVersion \"$__ClangMinorVersion\""

source "$scriptDir/find-clang.sh" $__ClangMajorVersion "$__ClangMinorVersion"

if [[ $__StaticAnalyzer == 1 ]]; then

scan_build=scan-build

fi

else

echo "Invoking \"$scriptDir/find-gcc.sh\" \"$__GccMajorVersion\" \"$__GccMinorVersion\""

source "$scriptDir/find-gcc.sh" "$__GccMajorVersion" "$__GccMinorVersion"

fi

if [[ -n "$__CodeCoverage" ]]; then

extraCmakeArguments="$extraCmakeArguments -DCLR_CMAKE_ENABLE_CODE_COVERAGE=1"

fi

nextCommand="\"$scriptDir/gen-buildsys.sh\" \"$__ProjectRoot\" \"$intermediatesForBuild\" $platformArch $__BuildType $generator $scan_build $extraCmakeArguments $__cmakeargs"

echo "Invoking $nextCommand"

eval $nextCommand

if [ $? != 0 ]; then

echo "${__ErrMsgPrefix}Failed to generate $message build project!"

exit 1

fi

fi

if [ ! -f "$intermediatesForBuild/CMakeCache.txt" ]; then

echo "${__ErrMsgPrefix}Unable to find generated build files for $message project!"

exit 1

fi

# Build

if [ $__ConfigureOnly == 1 ]; then

echo "Finish configuration & skipping $message build."

return

fi

# Check that the makefiles were created.

if [ $__StaticAnalyzer == 1 ]; then

pushd "$intermediatesForBuild"

buildTool="$SCAN_BUILD_COMMAND $buildTool"

echo "Executing $buildTool install -j $__NumProc"

$buildTool install -j $__NumProc

popd

else

echo "Executing cmake --build \"$intermediatesForBuild\" --target install -j $__NumProc"

cmake --build "$intermediatesForBuild" --target install -j $__NumProc

fi

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to build $message."

exit $exit_code

fi

{

local intermediatesForBuild="$__IntermediatesDir/Host$__CrossArch/crossgen"

local crossArchBinDir="$__BinDir/$__CrossArch"

mkdir -p "$intermediatesForBuild"

mkdir -p "$crossArchBinDir"

generate_event_logging_sources "$intermediatesForBuild" "the crossarch build system"

__SkipCrossArchBuild=1

# check supported cross-architecture components host(__HostArch)/target(__BuildArch) pair

if [[ ("$__BuildArch" == "arm" || "$__BuildArch" == "armel") && ("$__CrossArch" == "x86" || "$__CrossArch" == "x64") ]]; then

__SkipCrossArchBuild=0

elif [[ "$__BuildArch" == "arm64" && "$__CrossArch" == "x64" ]]; then

__SkipCrossArchBuild=0

else

# not supported

return

fi

export __CMakeBinDir="$crossArchBinDir"

export CROSSCOMPILE=0

__ExtraCmakeArgs="-DCLR_CMAKE_TARGET_ARCH=$__BuildArch -DCLR_CMAKE_PGO_INSTRUMENT=$__PgoInstrument -DCLR_CMAKE_OPTDATA_PATH=$__PgoOptDataPath -DCLR_CMAKE_PGO_OPTIMIZE=$__PgoOptimize -DCLR_CROSS_COMPONENTS_BUILD=1"

build_native $__SkipCrossArchBuild "$__CrossArch" "$intermediatesForBuild" "$__ExtraCmakeArgs" "cross-architecture components"

export CROSSCOMPILE=1

{

local __CrossGenExec=$1

local __CoreLibILDir=$2

if [ $__PartialNgen == 1 ]; then

export COMPlus_PartialNGen=1

fi

if [ -e $__CrossGenCoreLibLog ]; then

rm $__CrossGenCoreLibLog

fi

echo "Generating native image of System.Private.CoreLib.dll for $__BuildOS.$__BuildArch.$__BuildType. Logging to \"$__CrossGenCoreLibLog\"."

echo "$__CrossGenExec /Platform_Assemblies_Paths $__CoreLibILDir $__IbcTuning /out $__BinDir/System.Private.CoreLib.dll $__CoreLibILDir/System.Private.CoreLib.dll"

$__CrossGenExec /Platform_Assemblies_Paths $__CoreLibILDir $__IbcTuning /out $__BinDir/System.Private.CoreLib.dll $__CoreLibILDir/System.Private.CoreLib.dll >> $__CrossGenCoreLibLog 2>&1

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to generate native image for System.Private.CoreLib. Refer to $__CrossGenCoreLibLog"

exit $exit_code

fi

if [ "$__BuildOS" == "Linux" ]; then

echo "Generating symbol file for System.Private.CoreLib.dll"

echo "$__CrossGenExec /Platform_Assemblies_Paths $__BinDir /CreatePerfMap $__BinDir $__BinDir/System.Private.CoreLib.dll"

$__CrossGenExec /Platform_Assemblies_Paths $__BinDir /CreatePerfMap $__BinDir $__BinDir/System.Private.CoreLib.dll >> $__CrossGenCoreLibLog 2>&1

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to generate symbol file for System.Private.CoreLib. Refer to $__CrossGenCoreLibLog"

exit $exit_code

fi

fi

{

if [ $__isMSBuildOnNETCoreSupported == 0 ]; then

echo "System.Private.CoreLib.dll build unsupported."

return

fi

if [ $__SkipMSCorLib == 1 ]; then

echo "Skipping building System.Private.CoreLib."

return

fi

echo "Commencing build of managed components for $__BuildOS.$__BuildArch.$__BuildType"

# Invoke MSBuild

__ExtraBuildArgs=""

if [[ "$__IbcTuning" == "" ]]; then

__ExtraBuildArgs="$__ExtraBuildArgs /p:OptimizationDataDir=\"$__IbcOptDataPath/data\""

__ExtraBuildArgs="$__ExtraBuildArgs /p:EnableProfileGuidedOptimization=true"

fi

if [[ "$__BuildManagedTools" -eq "1" ]]; then

__ExtraBuildArgs="$__ExtraBuildArgs /p:BuildManagedTools=true"

fi

"$__RepoRootDir/eng/common/msbuild.sh" $__ArcadeScriptArgs \

$__ProjectDir/src/build.proj /t:Restore \

/p:PortableBuild=true /maxcpucount /p:IncludeRestoreOnlyProjects=true \

/flp:Verbosity=normal\;LogFile=$__LogsDir/System.Private.CoreLib_$__BuildOS__$__BuildArch__$__BuildType.log \

/p:__IntermediatesDir=$__IntermediatesDir /p:__RootBinDir=$__RootBinDir \

$__CommonMSBuildArgs $__ExtraBuildArgs $__UnprocessedBuildArgs

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to restore managed components."

exit $exit_code

fi

"$__RepoRootDir/eng/common/msbuild.sh" $__ArcadeScriptArgs \

$__ProjectDir/src/build.proj \

/p:PortableBuild=true /maxcpucount \

/flp:Verbosity=normal\;LogFile=$__LogsDir/System.Private.CoreLib_$__BuildOS__$__BuildArch__$__BuildType.log \

/p:__IntermediatesDir=$__IntermediatesDir /p:__RootBinDir=$__RootBinDir \

$__CommonMSBuildArgs $__ExtraBuildArgs $__UnprocessedBuildArgs

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to build managed components."

exit $exit_code

fi

if [[ "$__BuildManagedTools" -eq "1" ]]; then

echo "Publishing crossgen2 for $__DistroRid"

"$__ProjectRoot/dotnet.sh" publish --self-contained -r $__DistroRid -c $__BuildType -o "$__BinDir/crossgen2" "$__ProjectRoot/src/tools/crossgen2/crossgen2/crossgen2.csproj" /p:BuildArch=$__BuildArch

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to build crossgen2."

exit $exit_code

fi

if [ "$__HostOS" == "OSX" ]; then

cp "$__BinDir/libclrjit.dylib" "$__BinDir/crossgen2/libclrjitilc.dylib"

cp "$__BinDir/libjitinterface.dylib" "$__BinDir/crossgen2/libjitinterface.dylib"

else

cp "$__BinDir/libclrjit.so" "$__BinDir/crossgen2/libclrjitilc.so"

cp "$__BinDir/libjitinterface.so" "$__BinDir/crossgen2/libjitinterface.so"

fi

fi

local __CoreLibILDir=$__BinDir/IL

if [ $__SkipCrossgen == 1 ]; then

echo "Skipping generating native image"

if [ $__CrossBuild == 1 ]; then

# Crossgen not performed, so treat the IL version as the final version

cp $__CoreLibILDir/System.Private.CoreLib.dll $__BinDir/System.Private.CoreLib.dll

fi

return

fi

# The cross build generates a crossgen with the target architecture.

if [ $__CrossBuild == 0 ]; then

if [ $__SkipCoreCLR == 1 ]; then

return

fi

# The architecture of host pc must be same architecture with target.

if [[ ( "$__HostArch" == "$__BuildArch" ) ]]; then

build_CoreLib_ni "$__BinDir/crossgen" $__CoreLibILDir

elif [[ ( "$__HostArch" == "x64" ) && ( "$__BuildArch" == "x86" ) ]]; then

build_CoreLib_ni "$__BinDir/crossgen" $__CoreLibILDir

elif [[ ( "$__HostArch" == "arm64" ) && ( "$__BuildArch" == "arm" ) ]]; then

build_CoreLib_ni "$__BinDir/crossgen" $__CoreLibILDir

else

exit 1

fi

else

if [[ ( "$__CrossArch" == "x86" ) && ( "$__BuildArch" == "arm" ) ]]; then

build_CoreLib_ni "$__CrossComponentBinDir/crossgen" $__CoreLibILDir

elif [[ ( "$__CrossArch" == "x64" ) && ( "$__BuildArch" == "arm" ) ]]; then

build_CoreLib_ni "$__CrossComponentBinDir/crossgen" $__CoreLibILDir

elif [[ ( "$__HostArch" == "x64" ) && ( "$__BuildArch" == "arm64" ) ]]; then

build_CoreLib_ni "$__CrossComponentBinDir/crossgen" $__CoreLibILDir

else

# Crossgen not performed, so treat the IL version as the final version

cp $__CoreLibILDir/System.Private.CoreLib.dll $__BinDir/System.Private.CoreLib.dll

fi

fi

{

# We can only generate nuget package if we also support building mscorlib as part of this build.

if [ $__isMSBuildOnNETCoreSupported == 0 ]; then

echo "Nuget package generation unsupported."

return

fi

# Since we can build mscorlib for this OS, did we build the native components as well?

if [[ $__SkipCoreCLR == 1 && $__CrossgenOnly == 0 ]]; then

echo "Unable to generate nuget packages since native components were not built."

return

fi

echo "Generating nuget packages for "$__BuildOS

echo "DistroRid is "$__DistroRid

echo "ROOTFS_DIR is "$ROOTFS_DIR

# Build the packages

# Package build uses the Arcade system and scripts, relying on it to restore required toolsets as part of build

$__RepoRootDir/eng/common/build.sh -r -b -projects $__SourceDir/.nuget/packages.builds \

-verbosity minimal -bl:$__LogsDir/Nuget_$__BuildOS__$__BuildArch__$__BuildType.binlog \

/p:PortableBuild=true \

/p:__IntermediatesDir=$__IntermediatesDir /p:__RootBinDir=$__RootBinDir /p:__DoCrossArchBuild=$__CrossBuild \

$__CommonMSBuildArgs $__UnprocessedBuildArgs

local exit_code=$?

if [ $exit_code != 0 ]; then

echo "${__ErrMsgPrefix}Failed to generate Nuget packages."

exit $exit_code

fi

case $1 in

crossgenonly|-crossgenonly)

__SkipMSCorLib=1

__SkipCoreCLR=1

__CrossgenOnly=1

;;

disableoss|-disableoss)

__SignTypeArg="/p:SignType=real"

;;

ibcinstrument|-ibcinstrument)

__IbcTuning="/Tuning"

;;

ignorewarnings|-ignorewarnings)

__IgnoreWarnings=1

__cmakeargs="$__cmakeargs -DCLR_CMAKE_WARNINGS_ARE_ERRORS=OFF"

;;

nopgooptimize|-nopgooptimize)

__PgoOptimize=0

__SkipRestoreOptData=1

;;

officialbuildid=*|-officialbuildid=*)

__Id=$(echo "$1" | cut -d'=' -f 2)

__OfficialBuildIdArg="/p:OfficialBuildId=$__Id"

;;

partialngen|-partialngen)

__PartialNgen=1

;;

pgoinstrument|-pgoinstrument)

__PgoInstrument=1

;;

skipcoreclr|-skipcoreclr)

# Accept "skipcoreclr" for backwards-compatibility.

__SkipCoreCLR=1

;;

skipcrossarchnative|-skipcrossarchnative)

__SkipCrossArchNative=1

;;

skipcrossgen|-skipcrossgen)

__SkipCrossgen=1

;;

skipmanagedtools|-skipmanagedtools)

__BuildManagedTools=0

;;

skipmscorlib|-skipmscorlib)

__SkipMSCorLib=1

;;

skipnuget|-skipnuget|skipbuildpackages|-skipbuildpackages)

__SkipNuget=1

;;

skiprestore|-skiprestore)

__SkipRestoreArg="/p:RestoreDuringBuild=false"

;;

staticanalyzer|-staticanalyzer)

__StaticAnalyzer=1

;;

stripsymbols|-stripsymbols)

__cmakeargs="$__cmakeargs -DSTRIP_SYMBOLS=true"

;;

*)

__UnprocessedBuildArgs+=("$1")

;;

esac