<CoreLibSharedDir>$([MSBuild]::NormalizeDirectory('$(LibrariesProjectRoot)', 'System.Private.CoreLib', 'src'))</CoreLibSharedDir>
</PropertyGroup>
+ <!-- Honor the generic RuntimeConfiguration property. -->
+ <PropertyGroup>
+ <CoreCLRConfiguration Condition="'$(CoreCLRConfiguration)' == ''">$(RuntimeConfiguration)</CoreCLRConfiguration>
+ <MonoConfiguration Condition="'$(MonoConfiguration)' == '' and '$(RuntimeConfiguration.ToLower())' != 'checked'">$(RuntimeConfiguration)</MonoConfiguration>
+ <!-- There's no checked configuration on Mono. -->
+ <MonoConfiguration Condition="'$(MonoConfiguration)' == '' and '$(RuntimeConfiguration.ToLower())' == 'checked'">Debug</MonoConfiguration>
+ </PropertyGroup>
+
<!-- Packaging properties -->
<PropertyGroup>
<!--
git clean -xdf
git pull upstream master & git push origin master
build -subsetCategory coreclr -c Release
-build -subsetCategory libraries -coreclrConfiguration Release
+build -subsetCategory libraries -runtimeConfiguration release
:: The above you may only perform once in a day, or when
:: you pull down significant new changes.
git clean -xdf
git pull upstream master & git push origin master
./build.sh -subsetcategory coreclr -c Release
-./build.sh -subsetcategory libraries -coreclrconfiguration Release
+./build.sh -subsetcategory libraries -runtimeconfiguration Release
# The above you may only perform once in a day, or when
# you pull down significant new changes.
For Linux:
```bash
-./build.sh -coreclrconfiguration Release
+./build.sh -runtimeconfiguration Release
```
For Windows:
```bat
-./build.cmd -coreclrConfiguration Release
+./build.cmd -runtimeconfiguration Release
```
Detailed information about building and testing runtimes and the libraries is in the documents linked below.
* [Unix](../../building/coreclr/linux-instructions.md)
* [macOS](../../building/coreclr/osx-instructions.md)
* [Windows](../../building/coreclr/README.md)
-2) [Build the libraries](../../building/libraries/README.md) in Release configuration. Pass the configuration of CoreCLR you just built to the build script (e.g. `-coreclrConfiguration Debug`).
+2) [Build the libraries](../../building/libraries/README.md) in Release configuration. Pass the configuration of CoreCLR you just built to the build script (e.g. `-runtimeconfiguration debug`).
3) From the src/coreclr directory run the following command:
* Non-Windows - `./build-test.sh`
* Windows - `build-test.cmd`
## Running Library Tests
Running library tests against Mono is straightforward regardless of configuration. Simply run the following commands:
-1. Build and set the TestRuntimeFlavor
+1. Build and set the RuntimeFlavor
```bash
-./build.sh /p:TestRuntimeFlavor=mono
+./build.sh /p:RuntimeFlavor=mono
```
or on Windows
```bat
-build.cmd /p:TestRuntimeFlavor=mono
+build.cmd /p:RuntimeFlavor=mono
```
2. cd into the test library of your choice (`cd src/libraries/<library>/tests`)
3. Run the tests
```
-dotnet msbuild /t:BuildAndTest /p:TestRuntimeFlavor=mono
+dotnet msbuild /t:BuildAndTest /p:RuntimeFlavor=mono
```
</PropertyGroup>
<PropertyGroup>
- <DefaultSubsetCategories>libraries-installer-coreclr</DefaultSubsetCategories>
+ <DefaultSubsetCategories>libraries-installer-coreclr-mono</DefaultSubsetCategories>
<DefaultInstallerSubsets>corehost-managed-depproj-pkgproj-bundle-installers-test</DefaultInstallerSubsets>
<!-- TODO: Split into multiple sets. -->
<DefaultLibrariesSubsets>all</DefaultLibrariesSubsets>
<ProjectToBuild Include="$(RepoToolsLocalDir)regenerate-readme-table.proj" />
</ItemGroup>
+ <!-- Honor the generic RuntimeConfiguration property. -->
+ <PropertyGroup>
+ <CoreCLRConfiguration Condition="'$(CoreCLRConfiguration)' == ''">$(RuntimeConfiguration)</CoreCLRConfiguration>
+ <MonoConfiguration Condition="'$(MonoConfiguration)' == '' and '$(RuntimeConfiguration.ToLower())' != 'checked'">$(RuntimeConfiguration)</MonoConfiguration>
+ <!-- There's no checked configuration on Mono. -->
+ <MonoConfiguration Condition="'$(MonoConfiguration)' == '' and '$(RuntimeConfiguration.ToLower())' == 'checked'">Debug</MonoConfiguration>
+ </PropertyGroup>
+
<ItemDefinitionGroup Condition="'$(CoreCLRConfiguration)' != ''">
<CoreClrProjectToBuild>
<Properties>Configuration=$(CoreCLRConfiguration)</Properties>
</CoreClrProjectToBuild>
</ItemDefinitionGroup>
+ <ItemDefinitionGroup Condition="'$(MonoConfiguration)' != ''">
+ <MonoProjectToBuild>
+ <Properties>Configuration=$(MonoConfiguration)</Properties>
+ </MonoProjectToBuild>
+ </ItemDefinitionGroup>
+
<ItemDefinitionGroup Condition="'$(LibrariesConfiguration)' != ''">
<LibrariesProjectToBuild>
<Properties>Configuration=$(LibrariesConfiguration)</Properties>
[string]$arch,
[string]$subsetCategory,
[string]$subset,
- [string]$coreClrConfiguration,
+ [string]$runtimeConfiguration,
[string]$librariesConfiguration,
[Parameter(ValueFromRemainingArguments=$true)][String[]]$properties
)
{
switch($argument)
{
- "build" { $arguments += " -build" }
- "buildtests" { if ($build -eq $true) { $arguments += " /p:BuildTests=true" } else { $arguments += " -build /p:BuildTests=only" } }
- "test" { $arguments += " -test" }
- "configuration" { $configuration = (Get-Culture).TextInfo.ToTitleCase($($PSBoundParameters[$argument])); $arguments += " /p:ConfigurationGroup=$configuration -configuration $configuration" }
+ "build" { $arguments += " -build" }
+ "buildtests" { if ($build -eq $true) { $arguments += " /p:BuildTests=true" } else { $arguments += " -build /p:BuildTests=only" } }
+ "test" { $arguments += " -test" }
+ "configuration" { $configuration = (Get-Culture).TextInfo.ToTitleCase($($PSBoundParameters[$argument])); $arguments += " /p:ConfigurationGroup=$configuration -configuration $configuration" }
+ "runtimeConfiguration" { $arguments += " /p:RuntimeConfiguration=$((Get-Culture).TextInfo.ToTitleCase($($PSBoundParameters[$argument])))" }
# This should be removed after we have finalized our ci build pipeline.
- "framework" { if ($PSBoundParameters[$argument].ToLowerInvariant() -eq 'netcoreapp') { $arguments += " /p:TargetGroup=netcoreapp5.0" } else { if ($PSBoundParameters[$argument].ToLowerInvariant() -eq 'netfx') { $arguments += " /p:TargetGroup=net472" } else { $arguments += " /p:TargetGroup=$($PSBoundParameters[$argument].ToLowerInvariant())"}}}
- "os" { $arguments += " /p:OSGroup=$($PSBoundParameters[$argument])" }
- "allconfigurations" { $arguments += " /p:BuildAllConfigurations=true" }
- "arch" { $arguments += " /p:ArchGroup=$($PSBoundParameters[$argument]) /p:TargetArchitecture=$($PSBoundParameters[$argument])" }
- "properties" { $arguments += " " + $properties }
- default { $arguments += " /p:$argument=$($PSBoundParameters[$argument])" }
+ "framework" { if ($PSBoundParameters[$argument].ToLowerInvariant() -eq 'netcoreapp') { $arguments += " /p:TargetGroup=netcoreapp5.0" } else { if ($PSBoundParameters[$argument].ToLowerInvariant() -eq 'netfx') { $arguments += " /p:TargetGroup=net472" } else { $arguments += " /p:TargetGroup=$($PSBoundParameters[$argument].ToLowerInvariant())"}}}
+ "os" { $arguments += " /p:OSGroup=$($PSBoundParameters[$argument])" }
+ "allconfigurations" { $arguments += " /p:BuildAllConfigurations=true" }
+ "arch" { $arguments += " /p:ArchGroup=$($PSBoundParameters[$argument]) /p:TargetArchitecture=$($PSBoundParameters[$argument])" }
+ "properties" { $arguments += " " + $properties }
+ default { $arguments += " /p:$argument=$($PSBoundParameters[$argument])" }
}
}
arguments="$arguments /p:BuildNativeStripSymbols=true"
shift 1
;;
- -coreclrconfiguration)
- arguments="$arguments /p:CoreCLRConfiguration=$2"
+ -runtimeconfiguration)
+ val="$(tr '[:lower:]' '[:upper:]' <<< ${2:0:1})${2:1}"
+ arguments="$arguments /p:RuntimeConfiguration=$val"
shift 2
;;
-librariesconfiguration)
# Build on the host machine, then simply copy artifacts to the target docker image.
# This should result in significantly lower build times, for now.
& "$REPO_ROOT_DIR/coreclr.cmd" -c Release
- & "$REPO_ROOT_DIR/libraries.cmd" -ci -c $configuration /p:CoreCLRConfiguration=Release
+ & "$REPO_ROOT_DIR/libraries.cmd" -ci -c $configuration -runtimeConfiguration release
# Dockerize the build artifacts
docker build --tag $imageName `
ARG CONFIGURATION=Release
RUN ./src/coreclr/build.sh -release -skiptests -clang9 && \
- ./libraries.sh -c $CONFIGURATION /p:CoreCLRConfiguration=Release
+ ./libraries.sh -c $CONFIGURATION -runtimeconfiguration release
FROM $SDK_BASE_IMAGE as target
if [ "$?" != "0" ]; then
exit 1;
fi
- sudo apt install cmake llvm-3.9 clang-3.9 lldb-3.9 liblldb-3.9-dev libunwind8 libunwind8-dev gettext libicu-dev liblttng-ust-dev libcurl4-openssl-dev libssl-dev libkrb5-dev libnuma-dev
+ sudo apt install cmake llvm-3.9 clang-3.9 lldb-3.9 liblldb-3.9-dev libunwind8 libunwind8-dev gettext libicu-dev liblttng-ust-dev libcurl4-openssl-dev libssl-dev libkrb5-dev libnuma-dev autoconf automake libtool build-essential
if [ "$?" != "0" ]; then
exit 1;
fi
if [ "$?" != "0" ]; then
exit 1;
fi
- brew install icu4c openssl
+ brew install icu4c openssl autoconf automake libtool pkg-config python3
if [ "$?" != "0" ]; then
exit 1;
fi
<MonoArtifactsPath Condition="'$(MonoOverridePath)' != ''">$([MSBuild]::NormalizeDirectory('$(MonoOverridePath)'))</MonoArtifactsPath>
<LibrariesArtifactsPath Condition="'$(LibrariesOverridePath)' != ''">$([MSBuild]::NormalizeDirectory('$(LibrariesOverridePath)'))</LibrariesArtifactsPath>
<LibrariesAllConfigurationsArtifactsPath Condition="'$(LibrariesAllConfigurationsOverridePath)' != ''">$([MSBuild]::NormalizeDirectory('$(LibrariesAllConfigurationsOverridePath)'))</LibrariesAllConfigurationsArtifactsPath>
+
+ <!-- Honor the RuntimeArtifactsPath property. -->
+ <CoreCLRArtifactsPath Condition="'$(CoreCLRArtifactsPath)' == ''">$(RuntimeArtifactsPath)</CoreCLRArtifactsPath>
+ <MonoArtifactsPath Condition="'$(MonoArtifactsPath)' == ''">$(RuntimeArtifactsPath)</MonoArtifactsPath>
</PropertyGroup>
<!--
stagedBuild: ${{ parameters.stagedBuild }}
variables: ${{ parameters.variables }}
pool: ${{ parameters.pool }}
- liveCoreClrBuildConfig: ${{ parameters.buildConfig }}
+ liveRuntimeBuildConfig: ${{ parameters.buildConfig }}
- ${{ if eq(parameters.osGroup, 'OSX') }}:
- script: |
$(setScriptToEchoAndFailOnNonZero)
- brew install pkgconfig icu4c openssl
+ brew install pkgconfig icu4c openssl autoconf automake libtool pkg-config python3
brew link --force icu4c
ln -s /usr/local/opt/openssl/lib/pkgconfig/libcrypto.pc /usr/local/lib/pkgconfig/
ln -s /usr/local/opt/openssl/lib/pkgconfig/libssl.pc /usr/local/lib/pkgconfig/
parameters:
+ runtimeFlavor: 'coreclr'
jobTemplate: ''
buildConfig: ''
platforms: []
archType: arm
platform: Linux_arm
container:
- image: ubuntu-16.04-cross-14.04-23cacb0-20191023143847
+ image: ubuntu-16.04-cross-14.04-23cacb0-20200121150126
registry: mcr
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: arm64
platform: Linux_arm64
container:
- image: ubuntu-16.04-cross-arm64-cfdd435-20191023143847
+ image: ubuntu-16.04-cross-arm64-cfdd435-20200121150126
registry: mcr
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: x64
platform: Linux_musl_x64
container:
- image: alpine-3.9-WithNode-0fc54a3-20190918214015
+ # alpine coreclr cmake errors on newer builds
+ ${{ if eq(parameters.runtimeFlavor, 'mono') }}:
+ image: alpine-3.9-WithNode-0fc54a3-20200121145958
+ ${{ if ne(parameters.runtimeFlavor, 'mono') }}:
+ image: alpine-3.9-WithNode-0fc54a3-20190918214015
registry: mcr
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: arm64
platform: Linux_musl_arm64
container:
- image: ubuntu-16.04-cross-arm64-alpine-406629a-20191023143847
+ image: ubuntu-16.04-cross-arm64-alpine-406629a-20200121150126
registry: mcr
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: x64
platform: Linux_x64
container:
- image: centos-7-f39df28-20191023143754
+ image: centos-7-bfcd90a-20200121150017
registry: mcr
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: wasm
platform: WebAssembly_wasm
container:
- image: ubuntu-16.04-a50a721-20191023143845
+ image: ubuntu-16.04-bfcd90a-20200121150106
registry: mcr
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
# osGroup: FreeBSD
# archType: x64
# jobParameters:
+# runtimeFlavor: ${{ parameters.runtimeFlavor }}
# buildConfig: ${{ parameters.buildConfig }}
# # There are no FreeBSD helix queues, so we don't run tests at the moment.
# helixQueues:
archType: x64
platform: OSX_x64
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: x64
platform: Windows_NT_x64
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: x86
platform: Windows_NT_x86
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: arm
platform: Windows_NT_arm
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
archType: arm64
platform: Windows_NT_arm64
jobParameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
stagedBuild: ${{ parameters.stagedBuild }}
buildConfig: ${{ parameters.buildConfig }}
${{ if eq(parameters.passPlatforms, true) }}:
- name: ROOTFS_DIR
value: ${{ parameters.jobParameters.crossrootfsDir }}
+ - ${{ if ne(parameters.jobParameters.runtimeFlavor, '') }}:
+ - name: runtimeFlavorName
+ ${{ if eq(parameters.jobParameters.runtimeFlavor, 'mono') }}:
+ value: Mono
+ ${{ if eq(parameters.jobParameters.runtimeFlavor, 'coreclr') }}:
+ value: CoreCLR
+
osGroup: ${{ parameters.osGroup }}
osSubgroup: ${{ parameters.osSubgroup }}
archType: ${{ parameters.archType }}
platformGroup: all
jobParameters:
isOfficialBuild: false
- liveCoreClrBuildConfig: checked
+ liveRuntimeBuildConfig: checked
#
# Checked test builds
# Send telemetry for all builds
enableTelemetry: true
- helixRepo: 'dotnet/coreclr'
+ helixRepo: 'dotnet/runtime'
helixType: ${{ parameters.helixType }}
enableMicrobuild: ${{ parameters.enableMicrobuild }}
- ${{ if and(eq(variables['System.TeamProject'], 'internal'), ne(variables['Build.Reason'], 'PullRequest')) }}:
- name: _HelixSource
- value: official/dotnet/coreclr/$(Build.SourceBranch)
+ value: official/dotnet/runtime/$(Build.SourceBranch)
- ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
- name: _HelixSource
- value: pr/dotnet/coreclr/$(Build.SourceBranch)
+ value: pr/dotnet/runtime/$(Build.SourceBranch)
- ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
- name: _HelixSource
- value: ci/dotnet/coreclr/$(Build.SourceBranch)
+ value: ci/dotnet/runtime/$(Build.SourceBranch)
- ${{ if ne(parameters.crossrootfsDir, '') }}:
- name: crossArg
parameters:
+ runtimeFlavor: 'coreclr'
platforms: []
jobParameters: []
buildConfig: Release
buildConfig: ${{ parameters.buildConfig }}
platforms: ${{ parameters.platforms }}
passPlatforms: true
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
jobParameters:
${{ insert }}: ${{ parameters.jobParameters }}
useOfficialAllConfigurations: false
buildFullPlatformManifest: false
- liveCoreClrBuildConfig: ''
+ liveRuntimeBuildConfig: ''
liveLibrariesBuildConfig: ''
+ runtimeFlavor: 'coreclr'
platforms: []
jobs:
- name: LiveOverridePathArgs
value: >-
- $(CoreCLRArtifactsArgs)
+ $(RuntimeArtifactsArgs)
$(LibrariesConfigurationArg)
$(LibrariesAllConfigurationsOverridePathArg)
$(AllArtifactsArgs)
- - name: CoreCLRArtifactsArgs
+ - name: RuntimeArtifactsArgs
value: ''
- name: LibrariesConfigurationArg
value: ''
- name: AllArtifactsArgs
value: ''
- - name: CoreClrDownloadPath
+ - name: RuntimeDownloadPath
value: ''
- name: LibrariesDownloadPath
value: ''
- name: AllArtifactsDownloadPath
value: ''
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
- - name: liveCoreClrLegName
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
+ - name: liveRuntimeLegName
value: ${{ format('{0}{1}_{2}_{3}',
parameters.osGroup,
parameters.osSubgroup,
parameters.archType,
- parameters.liveCoreClrBuildConfig) }}
- - name: CoreClrDownloadPath
- value: 'artifacts/transport/coreclr'
- - name: CoreCLRArtifactsArgs
+ parameters.liveRuntimeBuildConfig) }}
+ - name: RuntimeDownloadPath
+ value: 'artifacts/transport/${{ parameters.runtimeFlavor }}'
+ - name: RuntimeArtifactsArgs
value: >-
- /p:CoreCLROverridePath=${{ parameters.buildCommandSourcesDirectory }}$(CoreClrDownloadPath)
- /p:CoreCLRConfiguration=${{ parameters.liveCoreClrBuildConfig }}
- - name: CoreClrArtifactName
- value: CoreCLRProduct_$(liveCoreClrLegName)
+ /p:RuntimeArtifactsPath=$(buildCommandSourcesDirectory)$(RuntimeDownloadPath)
+ /p:RuntimeConfiguration=${{ parameters.liveRuntimeBuildConfig }}
+ - name: RuntimeArtifactName
+ value: $(runtimeFlavorName)Product_$(liveRuntimeLegName)
- ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
- name: liveLibrariesLegName
dependsOn:
- checkout
- ${{ parameters.dependsOn }}
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
- - coreclr_product_build_${{ format('{0}{1}_{2}_{3}',
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
+ - ${{ format('{0}_product_build_{1}{2}_{3}_{4}',
+ parameters.runtimeFlavor,
parameters.osGroup,
parameters.osSubgroup,
parameters.archType,
- parameters.liveCoreClrBuildConfig) }}
+ parameters.liveRuntimeBuildConfig) }}
- ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
- libraries_build_netcoreapp_${{ format('{0}{1}_{2}_{3}',
parameters.osGroup,
- libraries_build_allconfigurations_Windows_NT_x64_Release
- ${{ if eq(parameters.buildFullPlatformManifest, true) }}:
- ${{ each platform in parameters.platforms }}:
- - coreclr_product_build_${{ platform }}_${{ parameters.liveCoreClrBuildConfig }}
+ - ${{ parameters.runtimeFlavor }}_product_build_${{ platform }}_${{ parameters.liveRuntimeBuildConfig }}
- libraries_build_netcoreapp_${{ platform }}_${{ parameters.liveLibrariesBuildConfig }}
steps:
downloadType: specific
downloadPath: '$(Build.SourcesDirectory)/__download__/AllPlatforms/'
itemPattern: |
- CoreCLRProduct_*/**
+ $(runtimeFlavorName)Product_*/**
libraries_bin_*/**
- ${{ if eq(parameters.buildFullPlatformManifest, true) }}:
- ${{ each platform in parameters.platforms }}:
- task: ExtractFiles@1
- displayName: 'Unzip CoreCLR artifacts: ${{ platform }}'
+ displayName: 'Unzip $(runtimeFlavorName) artifacts: ${{ platform }}'
inputs:
archiveFilePatterns: |
- $(Build.SourcesDirectory)/__download__/AllPlatforms/CoreCLRProduct_${{ platform }}_${{ parameters.liveCoreClrBuildConfig }}.*
- destinationFolder: $(AllArtifactsDownloadPath)/CoreCLRProduct_${{ platform }}_${{ parameters.liveCoreClrBuildConfig }}/
+ $(Build.SourcesDirectory)/__download__/AllPlatforms/$(runtimeFlavorName)Product_${{ platform }}_${{ parameters.liveRuntimeBuildConfig }}.*
+ destinationFolder: $(AllArtifactsDownloadPath)/$(runtimeFlavorName)Product_${{ platform }}_${{ parameters.liveRuntimeBuildConfig }}/
cleanUnpackFolder: false
- task: ExtractFiles@1
displayName: 'Unzip Libraries artifacts: ${{ platform }}'
destinationFolder: $(AllArtifactsDownloadPath)/libraries_bin_${{ platform }}_${{ parameters.liveLibrariesBuildConfig }}/
cleanUnpackFolder: false
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
- template: /eng/pipelines/common/download-artifact-step.yml
parameters:
- unpackFolder: $(Build.SourcesDirectory)/$(CoreClrDownloadPath)
- artifactFileName: '$(CoreClrArtifactName)$(archiveExtension)'
- artifactName: '$(CoreClrArtifactName)'
- displayName: 'CoreCLR artifacts'
+ unpackFolder: $(Build.SourcesDirectory)/$(RuntimeDownloadPath)
+ artifactFileName: '$(RuntimeArtifactName)$(archiveExtension)'
+ artifactName: '$(RuntimeArtifactName)'
+ displayName: '$(runtimeFlavorName) artifacts'
- ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
- template: /eng/pipelines/common/download-artifact-step.yml
framework: ''
isOfficialBuild: false
isOfficialAllConfigurations: false
- liveCoreClrBuildConfig: ''
+ liveRuntimeBuildConfig: ''
+ runtimeFlavor: 'coreclr'
timeoutInMinutes: 150
condition: true
container: ''
- ${{ if eq(parameters.isOfficialBuild, 'true') }}:
- _msbuildCommonParameters: /p:OfficialBuildId=$(Build.BuildNumber)
- - _coreClrArtifactName: ''
- - _coreClrDownloadPath: ''
- - _coreClrArtifactsPathArg: ''
+ - _runtimeArtifactName: ''
+ - _runtimeDownloadPath: ''
+ - _runtimeArtifactsPathArg: ''
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
- - _coreClrDownloadPath: '$(Build.SourcesDirectory)/artifacts/transport/coreclr'
- - _coreClrArtifactName: 'CoreCLRProduct_${{ parameters.osGroup }}${{ parameters.osSubgroup }}_${{ parameters.archType }}_${{ parameters.liveCoreClrBuildConfig }}'
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
+ - _runtimeDownloadPath: '$(Build.SourcesDirectory)/artifacts/transport/${{ parameters.runtimeFlavor }}'
+ - _runtimeArtifactName: '$(runtimeFlavorName)Product_${{ parameters.osGroup }}${{ parameters.osSubgroup }}_${{ parameters.archType }}_${{ parameters.liveRuntimeBuildConfig }}'
- ${{ if ne(parameters.container, '') }}:
- - _coreClrArtifactsPathArg: '/p:CoreCLRArtifactsPath=${_CORECLRDOWNLOADPATH}'
+ - _runtimeArtifactsPathArg: '/p:RuntimeArtifactsPath=${_RUNTIMEDOWNLOADPATH}'
- ${{ if eq(parameters.container, '') }}:
- - _coreClrArtifactsPathArg: ' /p:CoreCLRArtifactsPath=$(_coreClrDownloadPath)'
+ - _runtimeArtifactsPathArg: ' /p:RuntimeArtifactsPath=$(_runtimeDownloadPath)'
# WebAssembly uses linux implementation detail
- ${{ if eq(parameters.osGroup, 'WebAssembly') }}:
- - _coreClrArtifactName: 'CoreCLRProduct_Linux_x64_${{ parameters.liveCoreClrBuildConfig }}'
+ - _runtimeArtifactName: '$(runtimeFlavorName)Product_Linux_x64_${{ parameters.liveRuntimeBuildConfig }}'
# Windows variables
- ${{ if eq(parameters.osGroup, 'Windows_NT') }}:
- ${{ if eq(parameters.isOfficialBuild, 'true') }}:
- _stripSymbolsArg: -stripSymbols
- - _buildArguments: -configuration ${{ parameters.buildConfig }} -ci -arch ${{ parameters.archType }} $(_finalFrameworkArg) $(_stripSymbolsArg) $(_testScopeArg) $(_warnAsErrorArg) $(_runtimeOSArg) $(_msbuildCommonParameters) $(_coreClrArtifactsPathArg)
+ - _buildArguments: -configuration ${{ parameters.buildConfig }} -ci -arch ${{ parameters.archType }} $(_finalFrameworkArg) $(_stripSymbolsArg) $(_testScopeArg) $(_warnAsErrorArg) $(_runtimeOSArg) $(_msbuildCommonParameters) $(_runtimeArtifactsPathArg)
- ${{ parameters.variables }}
dependsOn:
steps:
- template: /eng/pipelines/common/clone-checkout-bundle-step.yml
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
- template: /eng/pipelines/common/download-artifact-step.yml
parameters:
- unpackFolder: $(_coreClrDownloadPath)
- artifactFileName: '$(_coreClrArtifactName)$(archiveExtension)'
- artifactName: '$(_coreClrArtifactName)'
- displayName: 'CoreCLR build drop'
+ unpackFolder: $(_runtimeDownloadPath)
+ artifactFileName: '$(_runtimeArtifactName)$(archiveExtension)'
+ artifactName: '$(_runtimeArtifactName)'
+ displayName: '$(runtimeFlavorName) build drop'
- ${{ parameters.steps }}
isOfficialBuild: false
isOfficialAllConfigurations: false
- # When set to a non-empty value (Debug / Release), it determines CoreCLR
+ # When set to a non-empty value (Debug / Release), it determines the runtime's
# build configuration to use for building libraries and tests. Setting this
- # property implies a dependency of this job on the appropriate CoreCLR build
+ # property implies a dependency of this job on the appropriate runtime build
# and is used to construct the name of the Azure artifact representing
- # CoreCLR build to use for building the libraries and library tests.
- liveCoreClrBuildConfig: ''
+ # runtime build to use for building the libraries and library tests.
+ liveRuntimeBuildConfig: ''
+ runtimeFlavor: 'coreclr'
timeoutInMinutes: 150
preBuildSteps: []
framework: ${{ parameters.framework }}
isOfficialBuild: ${{ parameters.isOfficialBuild }}
isOfficialAllConfigurations: ${{ parameters.isOfficialAllConfigurations }}
- liveCoreClrBuildConfig: ${{ parameters.liveCoreClrBuildConfig }}
+ liveRuntimeBuildConfig: ${{ parameters.liveRuntimeBuildConfig }}
timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
preBuildSteps: ${{ parameters.preBuildSteps }}
container: ${{ parameters.container }}
name: build
displayName: 'Build'
- ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
+ ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
dependsOn:
- ${{ if ne(parameters.osGroup, 'WebAssembly') }}:
- - ${{ format('coreclr_product_build_{0}{1}_{2}_{3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.liveCoreClrBuildConfig) }}
+ - ${{ format('{0}_product_build_{1}{2}_{3}_{4}', parameters.runtimeFlavor, parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.liveRuntimeBuildConfig) }}
- ${{ if eq(parameters.osGroup, 'WebAssembly') }}:
- - ${{ format('coreclr_product_build_{0}{1}_{2}_{3}', 'linux', parameters.osSubgroup, 'x64', parameters.liveCoreClrBuildConfig) }}
+ - ${{ format('{0}_product_build_{1}{2}_{3}_{4}', parameters.runtimeFlavor, 'linux', parameters.osSubgroup, 'x64', parameters.liveRuntimeBuildConfig) }}
variables:
- _skipTestRestoreArg: /p:SkipTestRestore=true
- ${{ if eq(parameters.osGroup, 'OSX') }}:
- script: |
- brew install pkgconfig icu4c openssl
+ brew install pkgconfig icu4c openssl autoconf automake libtool pkg-config python3
brew link --force icu4c
ln -s /usr/local/opt/openssl/lib/pkgconfig/libcrypto.pc /usr/local/lib/pkgconfig/
ln -s /usr/local/opt/openssl/lib/pkgconfig/libssl.pc /usr/local/lib/pkgconfig/
archType: ''
framework: netcoreapp
isOfficialBuild: false
- liveCoreClrBuildConfig: ''
+ liveRuntimeBuildConfig: ''
timeoutInMinutes: 150
container: ''
publishTestArtifacs: true
framework: ${{ parameters.framework }}
isOfficialBuild: ${{ parameters.isOfficialBuild }}
condition: ${{ parameters.condition }}
- liveCoreClrBuildConfig: ${{ parameters.liveCoreClrBuildConfig }}
+ liveRuntimeBuildConfig: ${{ parameters.liveRuntimeBuildConfig }}
timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
container: ${{ parameters.container }}
pool: ${{ parameters.pool }}
parameters:
+ runtimeFlavor: ''
archGroup: ''
configuration: ''
creator: ''
- script: ${{ parameters.msbuildScript }}
$(Build.SourcesDirectory)/src/libraries/sendtohelix.proj
/t:test
+ /p:RuntimeFlavor=${{ parameters.runtimeFlavor }}
/p:ArchGroup=${{ parameters.archGroup }}
/p:ConfigurationGroup=${{ parameters.configuration }}
/p:OSGroup=${{ parameters.targetOS }}
framework: netcoreapp
runTests: true
testScope: outerloop
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
- ${{ if eq(variables['isFullMatrix'], false) }}:
- template: /eng/pipelines/common/platform-matrix.yml
framework: netcoreapp
runTests: true
testScope: outerloop
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
- ${{ if eq(variables['includeWindowsOuterloop'], true) }}:
- template: /eng/pipelines/common/platform-matrix.yml
archType: ''
framework: netcoreapp
isOfficialBuild: false
- liveCoreClrBuildConfig: ''
+ liveRuntimeBuildConfig: ''
+ runtimeFlavor: 'coreclr'
timeoutInMinutes: 150
pool: ''
testScope: ''
archType: ${{ parameters.archType }}
framework: ${{ parameters.framework }}
isOfficialBuild: ${{ parameters.isOfficialBuild }}
- liveCoreClrBuildConfig: ${{ parameters.liveCoreClrBuildConfig }}
+ liveRuntimeBuildConfig: ${{ parameters.liveRuntimeBuildConfig }}
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
container: '' # we just send to helix, no need to use a container.
condition: ${{ parameters.condition }}
pool: ${{ parameters.pool }}
- ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
- displayName: ${{ format('Test Run {0} CoreCLR', parameters.liveCoreClrBuildConfig) }}
- name: ${{ format('test_run_{0}_coreclr', parameters.liveCoreClrBuildConfig) }}
- ${{ if eq(parameters.liveCoreClrBuildConfig, '') }}:
+ ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
+ displayName: ${{ format('Test Run {0} {1}', parameters.liveRuntimeBuildConfig, parameters.runtimeFlavor) }}
+ name: ${{ format('test_run_{0}_{1}', parameters.liveRuntimeBuildConfig, parameters.runtimeFlavor) }}
+ ${{ if eq(parameters.liveRuntimeBuildConfig, '') }}:
displayName: 'Test Run'
name: test_run
dependsOn:
- ${{ format('libraries_build_{0}_{1}{2}_{3}_{4}', parameters.framework, parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
- ${{ format('libraries_test_build_{0}_{1}_{2}_{3}', parameters.framework, parameters.osGroup, parameters.dependsOnTestArchitecture, parameters.dependsOnTestBuildConfiguration) }}
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
- - ${{ format('coreclr_product_build_{0}{1}_{2}_{3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.liveCoreClrBuildConfig) }}
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
+ - ${{ format('{0}_product_build_{1}{2}_{3}_{4}', parameters.runtimeFlavor, parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.liveRuntimeBuildConfig) }}
variables:
- librariesTestsArtifactName: ${{ format('libraries_test_assets_{0}_{1}_{2}', parameters.osGroup, parameters.dependsOnTestArchitecture, parameters.dependsOnTestBuildConfiguration) }}
- _archiveTestsParameter: /p:ArchiveTests=true
- _skipTestRestoreArg: /p:SkipTestRestore=false
- _testRunNamePrefixSuffix: ''
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
- - _testRunNamePrefixSuffix: CoreCLR_${{ parameters.liveCoreClrBuildConfig }}
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
+ - _testRunNamePrefixSuffix: $(runtimeFlavorName)_${{ parameters.liveRuntimeBuildConfig }}
- ${{ parameters.variables }}
steps:
artifactName: $(librariesTestsArtifactName)
artifactFileName: $(librariesTestsArtifactName)$(archiveExtension)
- - ${{ if ne(parameters.liveCoreClrBuildConfig, '') }}:
+ - ${{ if ne(parameters.liveRuntimeBuildConfig, '') }}:
- script: $(_msbuildCommand) src/libraries/restore/runtime/runtime.depproj
- $(_coreClrArtifactsPathArg)
+ $(_runtimeArtifactsPathArg)
$(_runtimeOSArg)
+ /p:RuntimeFlavor=${{ parameters.runtimeFlavor }}
/p:ArchGroup=${{ parameters.archType }}
/p:ConfigurationGroup=${{ parameters.buildConfig }}
- displayName: Override CoreCLR from live drop
+ displayName: Override $(runtimeFlavorName) from live drop
- template: /eng/pipelines/libraries/helix.yml
parameters:
+ runtimeFlavor: ${{ parameters.runtimeFlavor }}
targetOS: ${{ parameters.osGroup }}
archGroup: ${{ parameters.archType }}
configuration: ${{ parameters.buildConfig }}
--- /dev/null
+parameters:
+ buildConfig: ''
+ archType: ''
+ osGroup: ''
+ osSubgroup: ''
+ platform: ''
+ container: ''
+ timeoutInMinutes: ''
+ stagedBuild: false
+ variables: {}
+ pool: ''
+ condition: true
+
+### Product build
+jobs:
+- template: xplat-pipeline-job.yml
+ parameters:
+ buildConfig: ${{ parameters.buildConfig }}
+ _BuildConfig: ${{ parameters.buildConfig }}
+ archType: ${{ parameters.archType }}
+ osGroup: ${{ parameters.osGroup }}
+ osSubgroup: ${{ parameters.osSubgroup }}
+ helixType: 'build/product/'
+ enableMicrobuild: true
+ stagedBuild: ${{ parameters.stagedBuild }}
+ pool: ${{ parameters.pool }}
+ condition: ${{ parameters.condition }}
+
+ # Compute job name from template parameters
+ name: ${{ format('mono_product_build_{0}{1}_{2}_{3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
+ displayName: ${{ format('Mono Product Build {0}{1} {2} {3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.buildConfig) }}
+
+ # Run all steps in the container.
+ # Note that the containers are defined in platform-matrix.yml
+ container: ${{ parameters.container }}
+
+ timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
+
+ gatherAssetManifests: true
+ variables:
+ - name: osGroup
+ value: ${{ parameters.osGroup }}
+ - name: osSubgroup
+ value: ${{ parameters.osSubgroup }}
+
+ - ${{ parameters.variables }}
+
+ steps:
+
+ # Install native dependencies
+ # Linux builds use docker images with dependencies preinstalled,
+ # and FreeBSD builds use a build agent with dependencies
+ # preinstalled, so we only need this step for OSX and Windows.
+ - ${{ if eq(parameters.osGroup, 'OSX') }}:
+ - script: sh $(Build.SourcesDirectory)/eng/install-native-dependencies.sh $(osGroup)
+ displayName: Install native dependencies
+ - ${{ if eq(parameters.osGroup, 'Windows_NT') }}:
+ # Necessary to install python
+ - script: $(Build.SourcesDirectory)\eng\common\init-tools-native.cmd -InstallDirectory $(Build.SourcesDirectory)\native-tools -Force
+ displayName: Install native dependencies
+
+ # Build
+ - ${{ if ne(parameters.osGroup, 'Windows_NT') }}:
+ - script: ./mono$(scriptExt) -configuration $(buildConfig) -arch $(archType) -ci
+ displayName: Build product
+ - ${{ if eq(parameters.osGroup, 'Windows_NT') }}:
+ - script: mono$(scriptExt) -configuration $(buildConfig) -arch $(archType) -ci
+ displayName: Build product
+
+ # Publish product output directory for consumption by tests.
+ - template: /eng/pipelines/common/upload-artifact-step.yml
+ parameters:
+ rootFolder: $(buildProductRootFolderPath)
+ includeRootFolder: false
+ archiveType: $(archiveType)
+ tarCompression: $(tarCompression)
+ archiveExtension: $(archiveExtension)
+ artifactName: $(buildProductArtifactName)
+ displayName: 'product build'
+
+ # Publish Logs
+ - task: PublishBuildArtifacts@1
+ displayName: Publish Logs
+ inputs:
+ pathtoPublish: $(Build.SourcesDirectory)/artifacts/log
+ artifactName: 'BuildLogs_$(osGroup)$(osSubgroup)_$(archType)_$(buildConfig)'
+ continueOnError: true
+ condition: always()
--- /dev/null
+parameters:
+ buildConfig: ''
+ archType: ''
+ osGroup: ''
+ osSubgroup: ''
+ name: ''
+ helixType: '(unspecified)'
+ container: ''
+ crossrootfsDir: ''
+ stagedBuild: false
+ strategy: ''
+ pool: ''
+
+ # arcade-specific parameters
+ condition: ''
+ continueOnError: false
+ dependsOn: ''
+ displayName: ''
+ timeoutInMinutes: ''
+ enableMicrobuild: ''
+ gatherAssetManifests: false
+
+ variables: {} ## any extra variables to add to the defaults defined below
+
+jobs:
+- template: /eng/common/templates/job/job.yml
+ parameters:
+
+ name: ${{ parameters.name }}
+ displayName: ${{ parameters.displayName }}
+ container: ${{ parameters.container }}
+ condition: ${{ parameters.condition }}
+ dependsOn:
+ - ${{ if ne(parameters.stagedBuild, true) }}:
+ - checkout
+ - ${{ if ne(parameters.dependsOn, '') }}:
+ - ${{ parameters.dependsOn }}
+
+ timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
+ continueOnError: ${{ parameters.continueOnError }}
+
+ # Send telemetry for all builds
+ enableTelemetry: true
+ helixRepo: 'dotnet/runtime'
+ helixType: ${{ parameters.helixType }}
+
+ enableMicrobuild: ${{ parameters.enableMicrobuild }}
+ enablePublishUsingPipelines: true
+
+ strategy: ${{ parameters.strategy }}
+
+ pool: ${{ parameters.pool }}
+
+ workspace:
+ clean: all
+
+ ${{ if eq(parameters.osGroup, 'Linux') }}:
+ agentOs: Ubuntu
+ ${{ if eq(parameters.osGroup, 'FreeBSD') }}:
+ agentOs: FreeBSD
+ ${{ if eq(parameters.osGroup, 'OSX') }}:
+ agentOs: MacOS
+ ${{ if eq(parameters.osGroup, 'Windows_NT') }}:
+ agentOs: Windows_NT
+
+ # Setting this results in the arcade job template including a step
+ # that gathers asset manifests and publishes them to pipeline
+ # storage. Only relevant for build jobs.
+ enablePublishBuildAssets: ${{ parameters.gatherAssetManifests }}
+
+ variables:
+ - name: buildConfig
+ value: ${{ parameters.buildConfig }}
+
+ - ${{ if eq(parameters.buildConfig, 'debug') }}:
+ - name: buildConfigUpper
+ value: 'Debug'
+
+ - ${{ if eq(parameters.buildConfig, 'release') }}:
+ - name: buildConfigUpper
+ value: 'Release'
+
+ - name: _BuildConfig
+ value: $(buildConfigUpper)
+
+ - name: archType
+ value: ${{ parameters.archType }}
+
+ - name: osGroup
+ value: ${{ parameters.osGroup }}
+
+ - name: osSubgroup
+ value: ${{ parameters.osSubgroup }}
+
+ - ${{ if and(eq(variables['System.TeamProject'], 'internal'), ne(variables['Build.Reason'], 'PullRequest')) }}:
+ - name: _HelixSource
+ value: official/dotnet/runtime/$(Build.SourceBranch)
+ - ${{ if and(eq(variables['System.TeamProject'], 'public'), eq(variables['Build.Reason'], 'PullRequest')) }}:
+ - name: _HelixSource
+ value: pr/dotnet/runtime/$(Build.SourceBranch)
+ - ${{ if and(eq(variables['System.TeamProject'], 'public'), ne(variables['Build.Reason'], 'PullRequest')) }}:
+ - name: _HelixSource
+ value: ci/dotnet/runtime/$(Build.SourceBranch)
+
+ - ${{ each variable in parameters.variables }}:
+ - ${{insert}}: ${{ variable }}
+
+ steps:
+ - template: /eng/pipelines/common/clone-checkout-bundle-step.yml
+
+ - ${{ parameters.steps }}
--- /dev/null
+parameters:
+ buildConfig: ''
+ archType: ''
+ osGroup: ''
+ osSubgroup: ''
+ name: ''
+ helixType: '(unspecified)'
+ container: ''
+ liveLibrariesBuildConfig: ''
+ stagedBuild: false
+ strategy: ''
+ pool: ''
+
+ # arcade-specific parameters
+ condition: true
+ continueOnError: false
+ dependsOn: ''
+ displayName: ''
+ timeoutInMinutes: ''
+ enableMicrobuild: ''
+ gatherAssetManifests: false
+
+ variables: {} ## any extra variables to add to the defaults defined below
+
+jobs:
+- template: xplat-job.yml
+ parameters:
+ buildConfig: ${{ parameters.buildConfig }}
+ archType: ${{ parameters.archType }}
+ osGroup: ${{ parameters.osGroup }}
+ osSubgroup: ${{ parameters.osSubgroup }}
+ name: ${{ parameters.name }}
+ helixType: ${{ parameters.helixType }}
+ container: ${{ parameters.container }}
+ stagedBuild: ${{ parameters.stagedBuild }}
+ strategy: ${{ parameters.strategy }}
+ pool: ${{ parameters.pool }}
+
+ # arcade-specific parameters
+ condition: and(succeeded(), ${{ parameters.condition }})
+ continueOnError: ${{ parameters.continueOnError }}
+ dependsOn: ${{ parameters.dependsOn }}
+ displayName: ${{ parameters.displayName }}
+ timeoutInMinutes: ${{ parameters.timeoutInMinutes }}
+ enableMicrobuild: ${{ parameters.enableMicrobuild }}
+ gatherAssetManifests: ${{ parameters.gatherAssetManifests }}
+
+ variables:
+ - name: buildProductArtifactName
+ value: 'MonoProduct_$(osGroup)$(osSubgroup)_$(archType)_$(buildConfig)'
+
+ - name: buildProductRootFolderPath
+ value: '$(Build.SourcesDirectory)/artifacts/bin/mono/$(osGroup).$(archType).$(buildConfigUpper)'
+
+ - librariesBuildArtifactName: ''
+ - librariesOverrideArg: ''
+ - librariesDownloadDir: ''
+
+ - ${{ if ne(parameters.liveLibrariesBuildConfig, '') }}:
+ - librariesBuildArtifactName: ${{ format('libraries_bin_{0}{1}_{2}_{3}', parameters.osGroup, parameters.osSubgroup, parameters.archType, parameters.liveLibrariesBuildConfig) }}
+ - librariesDownloadDir: $(Build.SourcesDirectory)/artifacts
+ - librariesOverrideArg: ' /p:LibrariesConfiguration=${{ parameters.liveLibrariesBuildConfig }}'
+
+ - ${{ each variable in parameters.variables }}:
+ - ${{insert}}: ${{ variable }}
+
+ steps: ${{ parameters.steps }}
- Windows_NT_arm64
jobParameters:
isOfficialBuild: ${{ variables.isOfficialBuild }}
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
#
# Build libraries AllConfigurations for packages
framework: allConfigurations
isOfficialBuild: ${{ variables.isOfficialBuild }}
isOfficialAllConfigurations: true
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
#
# Installer Build
- template: /eng/pipelines/installer/installer-matrix.yml
parameters:
jobParameters:
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
liveLibrariesBuildConfig: Release
isOfficialBuild: ${{ variables.isOfficialBuild }}
useOfficialAllConfigurations: true
- THIRD-PARTY-NOTICES.TXT
- docs/*
- src/installer/*
+ - src/mono/*
- src/libraries/*
- eng/pipelines/installer/*
+ - eng/pipelines/mono/*
+ - eng/pipelines/libraries/*
+ - subset: mono
+ include:
+ - src/libraries/System.Private.CoreLib/*
+ exclude:
+ - eng/Version.Details.xml
+ - '*.md'
+ - LICENSE.TXT
+ - PATENTS.TXT
+ - THIRD-PARTY-NOTICES.TXT
+ - docs/*
+ - src/installer/*
+ - src/coreclr/*
+ - src/libraries/*
+ - eng/pipelines/installer/*
+ - eng/pipelines/coreclr/*
- eng/pipelines/libraries/*
- subset: libraries
exclude:
- THIRD-PARTY-NOTICES.TXT
- docs/*
- src/installer/*
+ - src/mono/*
- src/coreclr/*
- eng/pipelines/coreclr/*
+ - eng/pipelines/mono/*
- eng/pipelines/installer/*
- subset: installer
include:
- THIRD-PARTY-NOTICES.TXT
- docs/*
- src/coreclr/*
+ - src/mono/*
- src/libraries/*
- eng/pipelines/coreclr/*
+ - eng/pipelines/mono/*
- eng/pipelines/libraries/*
#
#
# Build CoreCLR release
-# Only when CoreCLR is changed
# Always as they are needed by Installer and we always build and test the Installer.
#
- template: /eng/pipelines/common/platform-matrix.yml
eq(variables['isFullMatrix'], true))
#
+# Build Mono debug
+# Only when Mono is changed
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+ parameters:
+ jobTemplate: /eng/pipelines/mono/templates/build-job.yml
+ runtimeFlavor: mono
+ buildConfig: debug
+ platforms:
+ - OSX_x64
+ - Linux_x64
+ # - Linux_arm
+ # - Linux_arm64
+ - Linux_musl_x64
+ # - Linux_musl_arm64
+ - Windows_NT_x64
+ # - Windows_NT_x86
+ # - Windows_NT_arm
+ # - Windows_NT_arm64
+ jobParameters:
+ condition: >-
+ or(
+ eq(dependencies.checkout.outputs['SetPathVars_mono.containsChange'], true),
+ eq(variables['isFullMatrix'], true))
+
+#
+# Build Mono release
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+ parameters:
+ jobTemplate: /eng/pipelines/mono/templates/build-job.yml
+ runtimeFlavor: mono
+ buildConfig: release
+ platforms:
+ - OSX_x64
+ - Linux_x64
+ # - Linux_arm
+ # - Linux_arm64
+ - Linux_musl_x64
+ # - Linux_musl_arm64
+ - Windows_NT_x64
+ # - Windows_NT_x86
+ # - Windows_NT_arm
+ # - Windows_NT_arm64
+
+#
# Build libraries using live CoreLib
# These set of libraries are built always no matter what changed
# The reason for that is because Corelib and Installer needs it and
- Windows_NT_arm64
- Windows_NT_x86
jobParameters:
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
- template: /eng/pipelines/common/platform-matrix.yml
parameters:
- OSX_x64
- Windows_NT_x64
jobParameters:
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
#
# Libraries Build that only run when libraries is changed
#
- Windows_NT_x86
jobParameters:
framework: netcoreapp
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
condition: >-
or(
eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
isFullMatrix: ${{ variables.isFullMatrix }}
framework: allConfigurations
runTests: true
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
condition: >-
or(
eq(dependencies.checkout.outputs['SetPathVars_libraries.containsChange'], true),
- Windows_NT_arm
- Windows_NT_arm64
jobParameters:
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
liveLibrariesBuildConfig: Release
- template: /eng/pipelines/installer/installer-matrix.yml
- Linux_musl_x64
- Windows_NT_x64
jobParameters:
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
liveLibrariesBuildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
#
- Windows_NT_x64
jobParameters:
isOfficialBuild: false
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
testScope: innerloop
condition: >-
or(
eq(variables['isFullMatrix'], true))
#
-# Libraries Release Test Execution against a release runtime
+# Libraries Release Test Execution against a release mono runtime.
+#
+- template: /eng/pipelines/common/platform-matrix.yml
+ parameters:
+ jobTemplate: /eng/pipelines/libraries/run-test-job.yml
+ runtimeFlavor: mono
+ buildConfig: ${{ variables.debugOnPrReleaseOnRolling }}
+ platforms:
+ # - Windows_NT_x64
+ - OSX_x64
+ - Linux_x64
+ helixQueuesTemplate: /eng/pipelines/libraries/helix-queues-setup.yml
+ jobParameters:
+ isOfficialBuild: false
+ isFullMatrix: ${{ variables.isFullMatrix }}
+ framework: netcoreapp
+ testScope: innerloop
+ liveRuntimeBuildConfig: release
+ dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
+ dependsOnTestArchitecture: x64
+
+#
+# Libraries Release Test Execution against a release coreclr runtime
# Only when the PR contains a libraries change
#
- template: /eng/pipelines/common/platform-matrix.yml
isFullMatrix: ${{ variables.isFullMatrix }}
framework: netcoreapp
testScope: innerloop
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
dependsOnTestArchitecture: x64
condition: >-
eq(variables['isFullMatrix'], true))
#
-# Libraries Debug Test Execution against a release runtime
+# Libraries Debug Test Execution against a release coreclr runtime
# Only when the PR contains a libraries change
#
- template: /eng/pipelines/common/platform-matrix.yml
isFullMatrix: ${{ variables.isFullMatrix }}
framework: netcoreapp
testScope: innerloop
- liveCoreClrBuildConfig: release
+ liveRuntimeBuildConfig: release
dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
dependsOnTestArchitecture: x64
condition: >-
jobParameters:
framework: netcoreapp
testScope: innerloop
- liveCoreClrBuildConfig: checked
+ liveRuntimeBuildConfig: checked
dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
dependsOnTestArchitecture: x64
condition: >-
jobParameters:
framework: netcoreapp
testScope: innerloop
- liveCoreClrBuildConfig: checked
+ liveRuntimeBuildConfig: checked
dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
dependsOnTestArchitecture: x64
condition: >-
jobParameters:
framework: netcoreapp
testScope: innerloop
- liveCoreClrBuildConfig: checked
+ liveRuntimeBuildConfig: checked
dependsOnTestBuildConfiguration: ${{ variables.debugOnPrReleaseOnRolling }}
dependsOnTestArchitecture: x64
condition: >-
<RunScriptHost Condition="'$(TargetOS)' == 'Windows_NT'">$(RunScriptHostDir)dotnet.exe</RunScriptHost>
<RunScriptHost Condition="'$(TargetOS)' != 'Windows_NT'">$(RunScriptHostDir)dotnet</RunScriptHost>
- <MonoRspFile>$(RunWorkingDirectory)mono.issues.rsp</MonoRspFile>
+ <!-- TODO: remove rsp argument when rsp files are removed: https://github.com/dotnet/runtime/issues/1980. -->
+ <MonoRspFile>$(RunWorkingDirectory)$(MonoRspFileName)</MonoRspFile>
</PropertyGroup>
<!-- Archive test binaries. -->
<Exec Condition="'$(TargetOS)' != 'Windows_NT'" Command="chmod +x $(RunScriptOutputPath)" />
<!-- Generate Mono .rsp file -->
+ <!-- TODO: remove when rsp files are removed: https://github.com/dotnet/runtime/issues/1980. -->
<ItemGroup>
- <MonoRspFiles Include="$(MonoProjectRoot)netcore\CoreFX.issues.rsp" />
- <MonoRspFiles Include="$(MonoProjectRoot)netcore\CoreFX.issues_mac.rsp" Condition="'$(TargetOS)' == 'OSX'" />
- <MonoRspFiles Include="$(MonoProjectRoot)netcore\CoreFX.issues_linux.rsp" Condition="'$(TargetOS)' == 'Linux'" />
- <MonoRspFiles Include="$(MonoProjectRoot)netcore\CoreFX.issues_windows.rsp" Condition="'$(TargetOS)' == 'Windows_NT'" />
+ <_rspFile Include="$(TestRspFile)" Condition="'$(TestRspFile)' != ''" />
+ <_rspFile Include="$(MonoProjectRoot)netcore\CoreFX.issues.rsp" />
+ <_rspFile Include="$(MonoProjectRoot)netcore\CoreFX.issues_mac.rsp" Condition="'$(TargetOS)' == 'OSX'" />
+ <_rspFile Include="$(MonoProjectRoot)netcore\CoreFX.issues_linux.rsp" Condition="'$(TargetOS)' == 'Linux'" />
+ <_rspFile Include="$(MonoProjectRoot)netcore\CoreFX.issues_windows.rsp" Condition="'$(TargetOS)' == 'Windows_NT'" />
</ItemGroup>
<ItemGroup>
- <MonoRspFileContent Include="$([System.IO.File]::ReadAllText(%(MonoRspFiles.Identity)))" />
+ <_rspFileContent Include="$([System.IO.File]::ReadAllText(%(_rspFile.Identity)))" />
</ItemGroup>
- <WriteLinesToFile File="$(MonoRspFile)" Lines="@(MonoRspFileContent)" Overwrite="true" />
+ <WriteLinesToFile File="$(MonoRspFile)" Lines="@(_rspFileContent)" Overwrite="true" />
</Target>
<Target Name="ValidateTestPlatform">
<PropertyGroup>
<RunTestsCommand>"$(RunScriptOutputPath)" --runtime-path "$(TestHostRootPath.TrimEnd('\/'))"</RunTestsCommand>
- <RunTestsCommand Condition="'$(TestRuntimeFlavor)' == 'Mono'">$(RunTestsCommand) --rsp-file "$(MonoRspFile)"</RunTestsCommand>
- <RunTestsCommand Condition="'$(TestRspFile)' != ''">$(RunTestsCommand) --rsp-file "$(TestRspFile)"</RunTestsCommand>
+ <!-- TODO: remove rsp argument when rsp files are removed: https://github.com/dotnet/runtime/issues/1980. -->
+ <RunTestsCommand Condition="'$(RuntimeFlavor)' == 'Mono'">$(RunTestsCommand) --rsp-file "$(MonoRspFile)"</RunTestsCommand>
+ <RunTestsCommand Condition="'$(TestRspFile)' != '' and '$(RuntimeFlavor)' != 'Mono'">$(RunTestsCommand) --rsp-file "$(TestRspFile)"</RunTestsCommand>
</PropertyGroup>
<!-- Invoke the run script with the test host as the runtime path. -->
<ILLinkClearInitLocals Condition="'$(IsSourceProject)' == 'true' and '$(Language)' != 'VB'">true</ILLinkClearInitLocals>
</PropertyGroup>
+ <PropertyGroup>
+ <MonoRspFileName>mono.issues.rsp</MonoRspFileName>
+ </PropertyGroup>
+
<PropertyGroup Condition="'$(BuildAllConfigurations)' != 'true'">
<!-- We add extra binplacing for the test shared framework until we can get hardlinking with the runtime directory working on all platforms -->
<BinPlaceTestSharedFramework Condition="'$(_bc_TargetGroup)' == '$(NetCoreAppCurrent)'">true</BinPlaceTestSharedFramework>
<!-- We're using ToolRuntimeRID as a placeholder for the real corelib/runtime components until we have an actual set of runtime bits to consume for webassembly. -->
<RuntimeIdentifier Condition="'$(RuntimeOS)' == 'webassembly'">$(ToolRuntimeRID)</RuntimeIdentifier>
<NoWarn>$(NoWarn);NU1603;NU1605</NoWarn>
- <SwapNativeForIL Condition="'$(SwapNativeForIL)' == '' and ('$(ConfigurationGroup)' == 'Debug' or '$(Coverage)' == 'true') and '$(TestRuntimeFlavor)' != 'Mono'">true</SwapNativeForIL>
+ <SwapNativeForIL Condition="'$(SwapNativeForIL)' == '' and ('$(ConfigurationGroup)' == 'Debug' or '$(Coverage)' == 'true') and '$(RuntimeFlavor)' != 'Mono'">true</SwapNativeForIL>
<CoreCLROSGroup Condition="'$(CoreCLROSGroup)' == ''">$(DefaultOSGroup)</CoreCLROSGroup>
<CoreCLRConfiguration Condition="'$(CoreCLRConfiguration)' == ''">$(ConfigurationGroup)</CoreCLRConfiguration>
<MonoOSGroup Condition="'$(MonoOSGroup)' == ''">$(DefaultOSGroup)</MonoOSGroup>
<Target Name="OverrideRuntimeCoreCLR"
DependsOnTargets="ResolveCoreCLRFilesFromLocalBuild"
AfterTargets="AfterResolveReferences;FilterNugetPackages"
- Condition="'$(TestRuntimeFlavor)' != 'Mono'">
+ Condition="'$(RuntimeFlavor)' != 'Mono'">
<ItemGroup>
<!-- CoreRun is not used for testing anymore, but we still use it for benchmarking and profiling -->
<CoreCLRFiles Include="$(CoreCLRArtifactsPath)/corerun*" />
<Target Name="OverrideRuntimeMono"
DependsOnTargets="ResolveMonoFilesFromLocalBuild"
AfterTargets="AfterResolveReferences;FilterNugetPackages"
- Condition="'$(TestRuntimeFlavor)' == 'Mono'">
+ Condition="'$(RuntimeFlavor)' == 'Mono'">
<ItemGroup>
<ReferenceCopyLocalPaths Include="@(MonoFiles)" />
</ItemGroup>
-->
<HelixCommand Condition="'$(TargetsWindows)' == 'true'">call RunTests.cmd --runtime-path %HELIX_CORRELATION_PAYLOAD%</HelixCommand>
<HelixCommand Condition="'$(TargetsWindows)' != 'true'">./RunTests.sh --runtime-path "$HELIX_CORRELATION_PAYLOAD"</HelixCommand>
+ <!-- TODO: remove rsp argument when rsp files are removed: https://github.com/dotnet/runtime/issues/1980. -->
+ <HelixCommand Condition="'$(RuntimeFlavor)' == 'mono'">$(HelixCommand) --rsp-file "$(MonoRspFileName)"</HelixCommand>
</PropertyGroup>
<!--
<Project>
-
<PropertyGroup>
<SkipImportArcadeSdkFromRoot>true</SkipImportArcadeSdkFromRoot>
</PropertyGroup>
<Import Project="..\..\Directory.Build.props" />
+
+ <!-- Set default Configuration and Platform -->
+ <PropertyGroup>
+ <OSGroup Condition="'$(OSGroup)' == '' and '$([MSBuild]::IsOSPlatform(Windows))' == 'true'">Windows_NT</OSGroup>
+ <OSGroup Condition="'$(OSGroup)' == '' and '$([MSBuild]::IsOSPlatform(Linux))' == 'true'">Linux</OSGroup>
+ <OSGroup Condition="'$(OSGroup)' == '' and '$([MSBuild]::IsOSPlatform(OSX))' == 'true'">OSX</OSGroup>
+
+ <ArchGroup Condition="'$(ArchGroup)' == ''">x64</ArchGroup>
+ <Platform>$(ArchGroup)</Platform>
+
+ <Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>
+
+ <PlatformConfigPathPart>$(OSGroup).$(Platform).$(Configuration)</PlatformConfigPathPart>
+ </PropertyGroup>
+
+ <!-- Common properties -->
+ <PropertyGroup>
+ <ProjectDir>$(MSBuildThisFileDirectory)</ProjectDir>
+ <SourceDir>$(ProjectDir)src\</SourceDir>
+ <BinDir>$(ArtifactsBinDir)mono\$(PlatformConfigPathPart)\</BinDir>
+
+ <BaseIntermediateOutputPath>$(ArtifactsObjDir)mono\$(MSBuildProjectName)\</BaseIntermediateOutputPath>
+ </PropertyGroup>
+
+ <PropertyGroup>
+ <!-- Central place to set the versions of all nuget packages produced in the repo -->
+ <PackageVersion Condition="'$(PackageVersion)' == ''">5.0.0</PackageVersion>
+
+ <!-- Set the boolean below to true to generate packages with stabilized versions -->
+ <StabilizePackageVersion Condition="'$(StabilizePackageVersion)' == ''">false</StabilizePackageVersion>
+ <StableVersion Condition="'$(StabilizePackageVersion)' == 'true' and '$(StableVersion)' == ''">$(PackageVersion)</StableVersion>
+
+ <PreReleaseLabel>preview8</PreReleaseLabel>
+ </PropertyGroup>
+
+ <!-- Set up common target properties that we use to conditionally include sources -->
+ <PropertyGroup>
+ <TargetsFreeBSD Condition="'$(OSGroup)' == 'FreeBSD'">true</TargetsFreeBSD>
+ <TargetsLinux Condition="'$(OSGroup)' == 'Linux'">true</TargetsLinux>
+ <TargetsNetBSD Condition="'$(OSGroup)' == 'NetBSD'">true</TargetsNetBSD>
+ <TargetsOSX Condition="'$(OSGroup)' == 'OSX'">true</TargetsOSX>
+ <TargetsWindows Condition="'$(OSGroup)' == 'Windows_NT'">true</TargetsWindows>
+ <TargetsUnix Condition="'$(TargetsFreeBSD)' == 'true' or '$(TargetsLinux)' == 'true' or '$(TargetsNetBSD)' == 'true' or '$(TargetsOSX)' == 'true'">true</TargetsUnix>
+ </PropertyGroup>
+
+ <PropertyGroup>
+ <LangVersion>8.0</LangVersion>
+ <UseSharedCompilation>true</UseSharedCompilation>
+ </PropertyGroup>
+
+ <!-- Set the kind of PDB to Portable -->
+ <PropertyGroup>
+ <DebugType Condition="'$(DebugType)' == ''">Portable</DebugType>
+ </PropertyGroup>
+
+ <!-- Output paths -->
+ <PropertyGroup>
+ <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+ </PropertyGroup>
<!-- Ensure our properties are set before Arcade defines defaults -->
- <Import Project="dir.common.props" />
<Import Project="Sdk.props" Sdk="Microsoft.DotNet.Arcade.Sdk" />
<PropertyGroup Condition="'$(CopyrightNetFoundation)' != ''">
-<?xml version="1.0" encoding="utf-8"?>
<Project>
<Import Project="..\..\Directory.Build.targets" />
SQLITE3="libsqlite3.so"
;;
*-*-*linux*)
- AC_PATH_X
- dlsearch_path=`(libtool --config ; echo eval echo \\$sys_lib_dlsearch_path_spec) | sh`
- AC_MSG_CHECKING(for the soname of libX11.so)
- for i in $x_libraries $dlsearch_path; do
- for r in 4 5 6; do
- if test -f $i/libX11.so.$r; then
- X11=libX11.so.$r
- AC_MSG_RESULT($X11)
- fi
+ if test "x$with_core" != "xonly"; then
+ AC_PATH_X
+ dlsearch_path=`(libtool --config ; echo eval echo \\$sys_lib_dlsearch_path_spec) | sh`
+ AC_MSG_CHECKING(for the soname of libX11.so)
+ for i in $x_libraries $dlsearch_path; do
+ for r in 4 5 6; do
+ if test -f $i/libX11.so.$r; then
+ X11=libX11.so.$r
+ AC_MSG_RESULT($X11)
+ fi
+ done
done
- done
-
- if test "x$X11" = "xlibX11.so"; then
- AC_MSG_WARN([Could not find libX11.so. Do you have X.org or XFree86 installed? Assuming libX11.so.6...]);
- X11=libX11.so.6
+
+ if test "x$X11" = "xlibX11.so"; then
+ AC_MSG_WARN([Could not find libX11.so. Do you have X.org or XFree86 installed? Assuming libX11.so.6...]);
+ X11=libX11.so.6
+ fi
fi
;;
esac
+++ /dev/null
-<Project>
-
- <!-- Set default Configuration and Platform -->
- <PropertyGroup>
- <BuildArch>$(__BuildArch)</BuildArch>
- <BuildArch Condition="'$(__BuildArch)'==''">x64</BuildArch>
- <BuildArch Condition="'$(__BuildArch)' == 'amd64'">x64</BuildArch>
-
- <BuildType>$(__BuildType)</BuildType>
- <BuildType Condition="'$(__BuildType)'==''">Debug</BuildType>
- <BuildType Condition="'$(__BuildType)' == 'debug'">Debug</BuildType>
- <BuildType Condition="'$(__BuildType)' == 'release'">Release</BuildType>
- <BuildType Condition="'$(__BuildType)' == 'checked'">Checked</BuildType>
-
- <BuildOS>$(__BuildOS)</BuildOS>
- <BuildOS Condition="'$(__BuildOS)' == '' And '$([MSBuild]::IsOSPlatform(Windows))' == 'true'">Windows_NT</BuildOS>
- <BuildOS Condition="'$(__BuildOS)' == '' And '$([MSBuild]::IsOSPlatform(Linux))' == 'true'">Linux</BuildOS>
- <BuildOS Condition="'$(__BuildOS)' == '' And '$([MSBuild]::IsOSPlatform(OSX))' == 'true'">OSX</BuildOS>
-
- <!-- TODO: converge on one property for BuildOS and __BuildOS (and similar), and remove these extra lines. -->
- <__BuildOS>$(BuildOS)</__BuildOS>
- <__BuildArch>$(BuildArch)</__BuildArch>
-
- <Configuration Condition="'$(Configuration)' == ''">$(BuildType)</Configuration>
- <Platform Condition="'$(Platform)' == ''">$(BuildArch)</Platform>
-
- <PlatformConfigPathPart>$(BuildOS).$(BuildArch).$(BuildType)</PlatformConfigPathPart>
-
- </PropertyGroup>
-
- <!-- Common properties -->
- <PropertyGroup>
-
- <__ProjectDir Condition="'$(__ProjectDir)'==''">$(MSBuildThisFileDirectory)</__ProjectDir>
- <ProjectDir>$(__ProjectDir)\</ProjectDir>
- <RootRepoDir>$(ProjectDir)\..\..\</RootRepoDir>
- <ProjectDir Condition="'$(__ProjectDir)'==''">$(MSBuildThisFileDirectory)</ProjectDir>
-
- <BaseIntermediateOutputPath>$(RootRepoDir)artifacts\obj\mono\$(MSBuildProjectName)\</BaseIntermediateOutputPath>
-
- <SourceDir>$(__SourceDir)\</SourceDir>
- <SourceDir Condition="'$(__SourceDir)'==''">$(ProjectDir)src\</SourceDir>
-
- <RootBinDir>$(__RootBinDir)\</RootBinDir>
- <RootBinDir Condition="'$(__RootBinDir)'==''">$(RootRepoDir)artifacts\</RootBinDir>
-
- <BinDir>$(__BinDir)\</BinDir>
- <BinDir Condition="'$(__BinDir)'==''">$(RootBinDir)bin\mono\$(PlatformConfigPathPart)\</BinDir>
-
- </PropertyGroup>
-
- <PropertyGroup>
- <!-- Central place to set the versions of all nuget packages produced in the repo -->
- <PackageVersion Condition="'$(PackageVersion)' == ''">5.0.0</PackageVersion>
-
- <!-- Set the boolean below to true to generate packages with stabilized versions -->
- <StabilizePackageVersion Condition="'$(StabilizePackageVersion)' == ''">false</StabilizePackageVersion>
- <StableVersion Condition="'$(StabilizePackageVersion)' == 'true' and '$(StableVersion)' == ''">$(PackageVersion)</StableVersion>
-
- <PreReleaseLabel>preview8</PreReleaseLabel>
- </PropertyGroup>
-
- <!-- Set up common target properties that we use to conditionally include sources -->
- <PropertyGroup>
- <TargetsFreeBSD Condition="'$(BuildOS)' == 'FreeBSD'">true</TargetsFreeBSD>
- <TargetsLinux Condition="'$(BuildOS)' == 'Linux'">true</TargetsLinux>
- <TargetsNetBSD Condition="'$(BuildOS)' == 'NetBSD'">true</TargetsNetBSD>
- <TargetsOSX Condition="'$(BuildOS)' == 'OSX'">true</TargetsOSX>
- <TargetsWindows Condition="'$(BuildOS)' == 'Windows_NT'">true</TargetsWindows>
-
- <TargetsUnix Condition="'$(TargetsFreeBSD)' == 'true' or '$(TargetsLinux)' == 'true' or '$(TargetsNetBSD)' == 'true' or '$(TargetsOSX)' == 'true'">true</TargetsUnix>
-
- </PropertyGroup>
-
- <PropertyGroup>
- <LangVersion>8.0</LangVersion>
- <UseSharedCompilation>true</UseSharedCompilation>
- </PropertyGroup>
-
- <!-- Set the kind of PDB to Portable -->
- <PropertyGroup>
- <DebugType Condition="'$(DebugType)' == ''">Portable</DebugType>
- </PropertyGroup>
-
- <!-- Common properties -->
- <PropertyGroup>
-
- <!-- Default to portable build if not explicitly set -->
- <PortableBuild Condition="'$(PortableBuild)' == ''">true</PortableBuild>
-
- <!-- If true, indicates that this is not an officially supported release -->
- <!-- It is important to flip this to false in official release branches -->
- <!-- Keep it in sync with PRERELEASE in clrdefinitions.cmake -->
- <IsPrerelease>true</IsPrerelease>
- </PropertyGroup>
-
- <!-- Output paths -->
- <PropertyGroup>
- <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
- </PropertyGroup>
-
-</Project>
</PropertyGroup>
<PropertyGroup>
<_MonoConfigureParams Condition="$(MonoEnableLLVM) == true">$(_MonoConfigureParams) --enable--llvm </_MonoConfigureParams>
- <_MonoConfigureParams>$(_MonoConfigureParams) --with-core=only CFLAGS="$(_MonoExtraCFLAGS)" CXXFLAGS="$(_MonoExtraCXXFLAGS)"</_MonoConfigureParams>
+ <_MonoConfigureParams>$(_MonoConfigureParams) --with-core=only CC=clang CXX=clang++ CFLAGS="$(_MonoExtraCFLAGS)" CXXFLAGS="$(_MonoExtraCXXFLAGS)"</_MonoConfigureParams>
</PropertyGroup>
<Message Text="Configuring Mono with '$(_MonoConfigureParams)'" Importance="High" />
<PropertyGroup>
<_MonoBuildParams>/p:MONO_BUILD_DIR_PREFIX=""$(MonoObjDir)"" /p:MONO_ENABLE_NETCORE=true /p:CL_MPCount=8 /v:minimal</_MonoBuildParams>
<_MonoBuildParams Condition="$(MonoEnableLLVM) == true">/p:MONO_ENABLE_LLVM=true $(_MonoBuildParams)</_MonoBuildParams>
+ <_MonoBuildPlatform Condition="'$(Platform)' == 'x64'">x64</_MonoBuildPlatform>
+ <_MonoBuildPlatform Condition="'$(Platform)' == 'x86'">win32</_MonoBuildPlatform>
</PropertyGroup>
- <Exec Command="msvc\run-msbuild.bat build $(Platform) $(Configuration) sgen "$(_MonoBuildParams)" msvc\mono-netcore.sln" IgnoreStandardErrorWarningFormat="true" />
+ <Exec Command="msvc\run-msbuild.bat build $(_MonoBuildPlatform) $(Configuration) sgen "$(_MonoBuildParams)" msvc\mono-netcore.sln" IgnoreStandardErrorWarningFormat="true" />
</Target>
<!-- General targets -->
<Target Name="Build" DependsOnTargets="BuildMonoRuntimeUnix;BuildMonoRuntimeWindows">
<PropertyGroup>
- <_MonoRuntimeFilePath Condition="'$(BuildOS)' == 'Windows_NT'">$(MonoObjDir)$(Platform)\Bin\$(Configuration)\mono-2.0-sgen.dll</_MonoRuntimeFilePath>
- <_MonoRuntimeFilePath Condition="'$(BuildOS)' == 'OSX'">$(MonoObjDir)mono\mini\.libs\libmonosgen-2.0.dylib</_MonoRuntimeFilePath>
+ <_MonoRuntimeFilePath Condition="'$(TargetsWindows)' == 'true' and '$(Platform)' == 'x64'">$(MonoObjDir)x64\Bin\$(Configuration)\mono-2.0-sgen.dll</_MonoRuntimeFilePath>
+ <_MonoRuntimeFilePath Condition="'$(TargetsWindows)' == 'true' and '$(Platform)' == 'x86'">$(MonoObjDir)Win32\Bin\$(Configuration)\mono-2.0-sgen.dll</_MonoRuntimeFilePath>
+ <_MonoRuntimeFilePath Condition="'$(TargetsOSX)' == 'true'">$(MonoObjDir)mono\mini\.libs\libmonosgen-2.0.dylib</_MonoRuntimeFilePath>
<_MonoRuntimeFilePath Condition="'$(_MonoRuntimeFilePath)' == ''">$(MonoObjDir)mono\mini\.libs\libmonosgen-2.0.so</_MonoRuntimeFilePath>
- <_CoreClrFileName Condition="'$(BuildOS)' == 'Windows_NT'">coreclr.dll</_CoreClrFileName>
- <_CoreClrFileName Condition="'$(BuildOS)' == 'OSX'">libcoreclr.dylib</_CoreClrFileName>
+ <_CoreClrFileName Condition="'$(TargetsWindows)' == 'true'">coreclr.dll</_CoreClrFileName>
+ <_CoreClrFileName Condition="'$(TargetsOSX)' == 'true'">libcoreclr.dylib</_CoreClrFileName>
<_CoreClrFileName Condition="'$(_CoreClrFileName)' == ''">libcoreclr.so</_CoreClrFileName>
</PropertyGroup>
--- /dev/null
+<Project>
+ <!-- Ignore Directory.Build.props from root for msvc build -->
+</Project>
--- /dev/null
+<Project>
+ <!-- Ignore Directory.Build.targets from root for msvc build -->
+</Project>
-nomethod System.Collections.Specialized.Tests.NameValueCollectionCtorTests.Ctor_NegativeCapacity_ThrowsArgumentOutOfRangeException
####################################################################
+## System.Collections.Concurrent.Tests
+####################################################################
+
+# fails only with release mono
+-nomethod System.Collections.Concurrent.Tests.ConcurrentQueueTests.ReferenceTypes_NulledAfterDequeue
+
+####################################################################
## System.Diagnostics.Tracing.Tests
####################################################################
-nomethod System.Reflection.Tests.AssemblyTests.LoadFile_PartiallyQualifiedPath_ThrowsArgumentException
-nomethod System.Reflection.Tests.AssemblyTests.LoadFile_NoSuchPath_ThrowsFileNotFoundException
+# fails on Helix
+-nomethod System.Reflection.Tests.AssemblyTests.LoadFromStream_Location_IsEmpty
+
####################################################################
## System.Runtime.InteropServices.Tests
####################################################################
-nomethod System.Runtime.Loader.Tests.AssemblyLoadContextTest.LoadFromNativeImagePath_PartiallyQualifiedPath_ThrowsArgumentException
-nomethod System.Runtime.Loader.Tests.AssemblyLoadContextTest.LoadFromNativeImagePath_PartiallyQualifiedPath_ThrowsArgumentException2
+# fails
+-nomethod System.Runtime.Loader.Tests.DefaultLoadContextTests.LoadNonExistentInDefaultContext
+-nomethod System.Runtime.Loader.Tests.AssemblyLoadContextTest.GetLoadContextTest_ValidUserAssembly
+-nomethod System.Runtime.Loader.Tests.DefaultLoadContextTests.LoadInDefaultContext
+-nomethod System.Runtime.Loader.Tests.AssemblyLoadContextTest.LoadFromAssemblyName_AssemblyNotFound
+-nomethod System.Runtime.Loader.Tests.AssemblyLoadContextTest.LoadAssemblyByPath_ValidUserAssembly
+-nomethod System.Runtime.Loader.Tests.AssemblyLoadContextTest.LoadAssemblyByStream_ValidUserAssembly
+-nomethod System.Runtime.Loader.Tests.AssemblyLoadContextTest.LoadFromAssemblyName_ValidTrustedPlatformAssembly
+
####################################################################
## System.Reflection.MetadataLoadContext.Tests
####################################################################
-nomethod System.Net.Http.Tests.Utf8StringContentTests.*
####################################################################
+## System.Text.RegularExpressions.Tests
+####################################################################
+
+# hits OOM
+-nomethod System.Text.RegularExpressions.Tests.RegexMatchTests.Match_Timeout_Loop_Throws
+
+####################################################################
## System.ComponentModel.Composition.Registration.Tests
####################################################################
# https://github.com/mono/mono/issues/18067 LLVM: try-catch doesn't catch an exception
-nomethod System.Reflection.Tests.BindingFlagsDoNotWrapTests.*
+
+# fail on Helix on RedHat systems because libgdiplus can't be loaded
+-nomethod System.Runtime.Serialization.Formatters.Tests.BinaryFormatterTests.RoundtripManyObjectsInOneStream
+-nomethod System.Runtime.Serialization.Formatters.Tests.BinaryFormatterTests.ValidateBasicObjectsRoundtrip
+-nomethod System.Resources.Tests.ResourceManagerTests.GetObject_Images
+-nomethod System.Resources.Tests.ResourceManagerTests.GetObject_Images_ResourceSet
+-nomethod System.Resources.Tests.ResourceManagerTests.GetResourceSet_Images
+-nomethod System.Resources.Extensions.Tests.PreserializedResourceWriterTests.BinaryFormattedResources
+-nomethod System.Resources.Extensions.Tests.PreserializedResourceWriterTests.StreamResources
+-nomethod System.Resources.Extensions.Tests.PreserializedResourceWriterTests.BinaryFormattedResourcesWithoutTypeName
</ItemGroup>
<PropertyGroup>
- <Configuration Condition=" '$(Configuration)' == '' ">$(BuildType)</Configuration>
- <Platform Condition=" '$(Platform)' == '' ">$(BuildArch)</Platform>
- <Platform Condition=" '$(Platform)' == 'armel' ">arm</Platform>
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
<!-- This prevents the default MsBuild targets from referencing System.Core.dll -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
return new System.NotFiniteNumberException ();
case HResults.COR_E_NOTSUPPORTED:
return new System.NotSupportedException ();
- case HResults.COR_E_NULLREFERENCE:
+ case HResults.E_POINTER:
return new System.NullReferenceException ();
case HResults.COR_E_OBJECTDISPOSED:
return new System.ObjectDisposedException ("");
case HResults.COR_E_AMBIGUOUSIMPLEMENTATION:
case HResults.COR_E_CANNOTUNLOADAPPDOMAIN:
case HResults.COR_E_CONTEXTMARSHAL:
- case HResults.COR_E_HOSTPROTECTION:
+ //case HResults.COR_E_HOSTPROTECTION:
case HResults.COR_E_INSUFFICIENTMEMORY:
case HResults.COR_E_INVALIDCOMOBJECT:
case HResults.COR_E_KEYNOTFOUND:
case HResults.COR_E_MISSINGSATELLITEASSEMBLY:
case HResults.COR_E_SAFEARRAYRANKMISMATCH:
case HResults.COR_E_SAFEARRAYTYPEMISMATCH:
- case HResults.COR_E_SAFEHANDLEMISSINGATTRIBUTE:
- case HResults.COR_E_SEMAPHOREFULL:
- case HResults.COR_E_THREADSTOP:
+ //case HResults.COR_E_SAFEHANDLEMISSINGATTRIBUTE:
+ //case HResults.COR_E_SEMAPHOREFULL:
+ //case HResults.COR_E_THREADSTOP:
case HResults.COR_E_TIMEOUT:
case HResults.COR_E_WAITHANDLECANNOTBEOPENED:
case HResults.DISP_E_OVERFLOW:
<!-- Distro rid is passed as runtimeos-arch-->
<_parseDistroRid>$(__DistroRid)</_parseDistroRid>
- <_parseDistroRid Condition="'$(_parseDistroRid)' == '' and '$(__BuildOS)' == 'OSX'">osx.10.12-x64</_parseDistroRid>
+ <_parseDistroRid Condition="'$(_parseDistroRid)' == '' and '$(TargetsOSX)' == 'true'">osx.10.12-x64</_parseDistroRid>
<_distroRidIndex>$(_parseDistroRid.IndexOfAny("-"))</_distroRidIndex>
<_archRidIndex>$([MSBuild]::Add($(_distroRidIndex), 1))</_archRidIndex>
<OSRid Condition="'$(OSRid)' == '' and '$(_distroRidIndex)' != '-1'">$(_parseDistroRid.SubString(0, $(_distroRidIndex)))</OSRid>
<OSRid Condition="'$(OSRid)' == ''">win10</OSRid>
- <ArchGroup Condition="'$(ArchGroup)' == '' and '$(_archRidIndex)' != '0'">$(_parseDistroRid.SubString($(_archRidIndex)))</ArchGroup>
- <ArchGroup Condition="'$(ArchGroup)' == '' and '$(Platform)' != ''">$(Platform)</ArchGroup>
- <ArchGroup Condition="'$(ArchGroup)' == ''">$(BuildArch)</ArchGroup>
-
<RuntimeOS Condition="'$(RuntimeOS)' == ''">$(OSRid)</RuntimeOS>
<SupportedPackageOSGroups Condition="'$(SupportedPackageOSGroups)' == ''">Windows_NT;OSX;Android;Linux;FreeBSD</SupportedPackageOSGroups>
<_derivedPackageTargetOSGroup Condition="'$(_derivedPackageTargetOSGroup)' == '' and '$(_runtimeOSFamily)' == 'osx'">OSX</_derivedPackageTargetOSGroup>
<_derivedPackageTargetOSGroup Condition="'$(_derivedPackageTargetOSGroup)' == '' and '$(_runtimeOSFamily)' == 'android'">Android</_derivedPackageTargetOSGroup>
<_derivedPackageTargetOSGroup Condition="'$(_derivedPackageTargetOSGroup)' == '' and '$(_runtimeOSFamily)' == 'win'">Windows_NT</_derivedPackageTargetOSGroup>
- <_derivedPackageTargetOSGroup Condition="'$(_derivedPackageTargetOSGroup)' == '' and '$(__BuildOS)' != ''">$(__BuildOS)</_derivedPackageTargetOSGroup>
+ <_derivedPackageTargetOSGroup Condition="'$(_derivedPackageTargetOSGroup)' == '' and '$(OSGroup)' != ''">$(OSGroup)</_derivedPackageTargetOSGroup>
<_derivedPackageTargetOSGroup Condition="'$(_derivedPackageTargetOSGroup)' == ''">Linux</_derivedPackageTargetOSGroup>
<_isSupportedOSGroup Condition="!$(SupportedPackageOSGroups.Contains(';$(_derivedPackageTargetOSGroup);'))">false</_isSupportedOSGroup>
<BuildingAnOfficialBuildLeg Condition="'$(OfficialBuildId)' != '' AND '$(DotNetBuildFromSource)' != 'true'">true</BuildingAnOfficialBuildLeg>
<!-- During an official build, only build identity packages on windows x64 legs -->
- <BuildIdentityPackage Condition="'$(BuildingAnOfficialBuildLeg)' == 'true' AND ('$(OS)' != 'Windows_NT' OR '$(BuildArch)' != 'x64')">false</BuildIdentityPackage>
+ <BuildIdentityPackage Condition="'$(BuildingAnOfficialBuildLeg)' == 'true' AND ('$(OS)' != 'Windows_NT' OR '$(Platform)' != 'x64')">false</BuildIdentityPackage>
</PropertyGroup>
<Target Name="FilterProjects" BeforeTargets="Build">
projects / platform / upstream / dotnet / runtime.git / commitdiff