Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

WIP: Support global.json on arm64 as well #14790

Merged
merged 1 commit into from
Nov 2, 2019

Conversation

omajid
Copy link
Member

@omajid omajid commented Oct 7, 2019

I am trying to get ASP.NET Core to build on linux/arm64 machines (not cross compiled on x86_64).

On such machines, global.json makes arcade download the arm64 SDK, then the x64 and/or x86 runtimes. Now there are two copies of hostfxr in the local SDK:

$ find .dotnet/host/
.dotnet/host/
.dotnet/host/fxr
.dotnet/host/fxr/5.0.0-alpha1.19415.3
.dotnet/host/fxr/5.0.0-alpha1.19415.3/libhostfxr.so
.dotnet/host/fxr/5.0.0-alpha1.19470.7
.dotnet/host/fxr/5.0.0-alpha1.19470.7/libhostfxr.so

One is an x64 binary, the other is the arm64 binary:

$ file .dotnet/host/fxr/5.0.0-alpha1.19415.3/libhostfxr.so
.dotnet/host/fxr/5.0.0-alpha1.19415.3/libhostfxr.so: ELF 64-bit LSB shared object, ARM aarch64, version 1 (SYSV), dynamically linked, BuildID[sha1]=824b0c0f19a62296726be7bd12cef294ee3732af, stripped
$ file .dotnet/host/fxr/5.0.0-alpha1.19470.7/libhostfxr.so
.dotnet/host/fxr/5.0.0-alpha1.19470.7/libhostfxr.so: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, BuildID[sha1]=511b71993bb9762f46d69f377145d622208165a5, stripped

Unfortunately, the higher version is the x64 binary. That can't be loaded or used on arm64. The ASP.NET Core build quickly runs into an error:

/home/omajid/.nuget/packages/microsoft.net.compilers.toolset/3.4.0-beta1-19456-03/tasks/netcoreapp2.1/Microsoft.CSharp.Core.targets(59,5): error : Failed to load �#|, error: /home/omajid/AspNetCore/.dotnet/host/fxr/5.0.0-alpha1.19470.7/libhostfxr.so: cannot open shared object file: No such file or directory [/home/omajid/AspNetCore/eng/tools/RepoTasks/RepoTasks.csproj]                       

This change removes architecture-specific download versions from global.json. This lets arcade download the arch-appropriate version of .NET Core which then lets the build continue past this error.

@omajid omajid requested a review from a team as a code owner October 7, 2019 15:52
Copy link
Member

@dougbu dougbu left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks @omajid

Just curious: What is your requirement to build on ARM64?

global.json Show resolved Hide resolved
@omajid
Copy link
Member Author

omajid commented Oct 7, 2019

Just curious: What is your requirement to build on ARM64?

This is part of the larger work that we are doing on source-build to enable arm64 (and arm32, thought that's not my current goal) builds: dotnet/source-build#750. The goal is that Linux distributions like Fedora should be able to build and run all of .NET Core on arm64 (not cross-compiled).

@dougbu
Copy link
Member

dougbu commented Oct 7, 2019

@livarcocc and @dagood who owns the dotnet-install scripts and the naming of the runtime packs?

It seems like some runtimes (arm64 and x86) are not available for Linux and the scripts skip them. However an arm64 SDK is available, just not one containing the runtime we need.

@omajid
Copy link
Member Author

omajid commented Oct 7, 2019

@dagood
Copy link
Member

dagood commented Oct 7, 2019

the naming of the runtime packs?

This is defined by dotnet/designs#50, but doesn't seem relevant here as the Packs are only involved in SDK build and publish scenarios. The Runtime and SDK layouts are over at https://github.com/dotnet/designs/blob/master/accepted/install-locations.md.

As I said in the original PR comments, the arm64 and x64 runtimes are slightly different (5.0.0-alpha1.19415.3 vs 5.0.0-alpha1.19470.7)... or overwritten? The x64 hostfxr is newer and wins at the end, resulting in anon-executible binary.

I don't have any underlying understanding of what Arcade or the dotnet install script are doing with the global.json, but it seems likely that the lower-versioned one is the one that the 5.0.100-alpha1-013788 SDK includes, and the higher one is based on MicrosoftNETCoreAppRuntimeVersion which seems like it would be updated more often.

@Pilchie Pilchie added the area-infrastructure Includes: MSBuild projects/targets, build scripts, CI, Installers and shared framework label Oct 8, 2019
@omajid
Copy link
Member Author

omajid commented Oct 9, 2019

@livarcocc @dagood @dougbu Any thoughts on what the next steps need to be? I am happy to do the legwork.

@dagood
Copy link
Member

dagood commented Oct 9, 2019

My guess would be that Arcade and/or the dotnet-install script needs a new feature to help with this situation, or something's broken. The next thing I'd try to do is isolate what is being installed and why, (why does it install x64 rather than x86 or arm64 with version MicrosoftNETCoreAppRuntimeVersion when all are specified?), then file a dotnet/arcade or dotnet/cli issue depending on what's going on.

@omajid
Copy link
Member Author

omajid commented Oct 11, 2019

Here's what I see on my end (linux, arm64):

x86 is not supported, because it's Linux. So it's completely skipped.

Arcade prints:

         Skipping installing x86 runtimes because this is a non-Windows platform and .NET Core x86 is not currently supported on any non-Windows platform.

This is from https://github.com/dotnet/arcade/blob/64a027b8d8b3a8e8e214bb00da02148335e3bd92/src/Microsoft.DotNet.Arcade.Sdk/src/InstallDotNetCore.cs#L95.

I am not sure how x86 and x64 combo works on Windows.

dotnet-install.sh follows the global.json order. It installs the runtimes in order of appearance in the json file.

The position of dotnet/x64 vs dotnet/arm64 matters. If I put dotnet/arm64 first, it works on my end (but would probably break on x64)

This does not work:

"runtimes": {
  "dotnet/x64": [
    "$(MicrosoftNETCoreAppRuntimeVersion)"
  ],
  "dotnet/x86": [
    "$(MicrosoftNETCoreAppRuntimeVersion)"
  ],
  "dotnet/arm64": [
    "$(MicrosoftNETCoreAppRuntimeVersion)"
  ]
}

The calls to dotnet-install.sh look like this:

.dotnet/dotnet-install.sh --version 5.0.100-alpha1-014696 --install-dir /home/omajid/aspnetcore-global-json/.dotnet
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture x64 --runtime dotnet --skip-non-versioned-files
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture arm64 --runtime dotnet --skip-non-versioned-files

This version of global.json works:

"runtimes": {
  "dotnet/arm64": [
    "$(MicrosoftNETCoreAppRuntimeVersion)"
  ],
  "dotnet/x64": [
    "$(MicrosoftNETCoreAppRuntimeVersion)"
  ],
  "dotnet/x86": [
    "$(MicrosoftNETCoreAppRuntimeVersion)"
  ]
}

The dotnet-install.sh script is called like this:

.dotnet/dotnet-install.sh --version 5.0.100-alpha1-014696 --install-dir /home/omajid/aspnetcore-global-json/.dotnet
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture arm64 --runtime dotnet --skip-non-versioned-files
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture x64 --runtime dotnet --skip-non-versioned-files
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture arm64 --runtime dotnet --skip-non-versioned-files
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture x64 --runtime dotnet --skip-non-versioned-files
If the runtime - irrespective of the architecture - is already installed, dotnet-install.sh does nothing.

The invocations to dotnet-install.sh look like this:

.dotnet/dotnet-install.sh --version 5.0.100-alpha1-014696 --install-dir /home/omajid/aspnetcore-global-json/.dotnet
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture x64 --runtime dotnet --skip-non-versioned-files
.dotnet/dotnet-install.sh --version 5.0.0-alpha1.19506.5 --install-dir /home/omajid/aspnetcore-global-json/.dotnet --architecture arm64 --runtime dotnet --skip-non-versioned-files

And for the last (arm64) invocation, dotnet-install says:

dotnet-install: .NET Core Runtime version 5.0.0-alpha1.19506.5 is already installed

I guess my main take-away is that dotnet-install.sh is completely unprepared to handle multiple installations of different architectures in the same location.

Does anyone know how this works on Windows with x86 and x64? Is it simply that x64 gets installed and x86 gets skipped?

Is this usage of dotnet-install.sh common? Should I try and modify dotnet-install.sh to handle multiple architectures? Or should I try and modify ASP.NET Core to put multiple installations in different locations?

@dougbu
Copy link
Member

dougbu commented Oct 12, 2019

Does anyone know how this works on Windows with x86 and x64? Is it simply that x64 gets installed and x86 gets skipped?

On Windows, the x64 SDK gets placed in .dotnet/ and the x86 runtime is added in .dotnet/x86/. If the requested x64 runtime is also newer than the default in the SDK, it's also placed in .dotnet/, adding new files and folders as needed e.g. adding .dotnet\shared\Microsoft.NETCore.App\5.0.0-alpha1.19506.5 plus the default .dotnet\shared\Microsoft.NETCore.App\5.0.0-alpha1.19467.5. .dotnet\x86\shared\Microsoft.NETCore.App contains only the 5.0.0-alpha1.19506.5 folder. In other words, on Windows two copies of the same runtime are installed but in different directories.

I suspect we have logic in various places to set environment variables and so on related to the dotnet install locations that understands "native goes in .dotnet/ and additional x86 runtime may be found in .dotnet/x86/ but minimal coverage for the arm64 case. Not sure whether the installer is doing the wrong thing for a second ARM64 runtime (@livarcocc @dsplaisted ?), you're hitting a problem in the repo code that handles different runtimes (@jkotalik I think you've done the most with handling the added x86 runtime; any suggestions?), or this is a problem in the Arcade SDK (@markwilkie, thoughts)?

My additional guess is that dotnet-install.sh or Arcade (probably Arcade) always places the x64 runtime in .dotnet/ even if the installed SDK is for ARM64.

So, @markwilkie is it possible to update that logic to instead place the matching runtime in .dotnet/? Would end up with the same layout on regular Linux and Windows as today but Linux ARM64 would look like

.dotnet/ - ARM64 SDK and latest ARM64 runtime
.dotnet/x64/ - latest x64 runtime (not sure whether the build will use this but it doesn't hurt)

instead of the current

.dotnet/ - ARM64 SDK and latest x64 runtime

@omajid
Copy link
Member Author

omajid commented Oct 16, 2019

My additional guess is that dotnet-install.sh or Arcade (probably Arcade) always places the x64 runtime in .dotnet/ even if the installed SDK is for ARM64.

From what I can tell, arcade simply calls eng/common/dotnet-install.sh (or dotnet-install.ps1) and lets it do its job. eng/common/dotnet-install.sh calls cli's ~/.dotnet/dotnet-install.sh, which has no special logic other than refusing to replace an already existing runtime with the same runtime; it ignores architectures completely. It looks like it simply installs x64 first (because it appears first in global.json) an then refuses to install other runtimes because they already exist (ignoring architecture).

eng/common/dotnet-install.ps1 actually contains some logic to look at the architecture and select between .dotnet/ and .dotnet/x86 based on the architecture. But it only handles x86 as a special case.

.dotnet/ - ARM64 SDK and latest ARM64 runtime
.dotnet/x64/ - latest x64 runtime (not sure whether the build will use this but it doesn't hurt)

Would it make sense to install the current architecture (whatever that is, arm64 in my case) to .dotnet and install other variants (x86, x64, even arm64 in case of building on x64) in .dotnet/${arch}/?

Edit: fix confusion caused by multiple files with the name dotnet-install.(sh|ps1)

global.json Show resolved Hide resolved
global.json Outdated Show resolved Hide resolved
@pranavkm
Copy link
Contributor

@omajid does this PR - dotnet/arcade#4132 - supersede this change?

@omajid
Copy link
Member Author

omajid commented Oct 23, 2019

@omajid does this PR - dotnet/arcade#4132 - supersede this change?

Not really; we will need that fix and then something like what @dougbu suggested above to be able to start a build on arm64 at all.

arcade uses the runtime section of global.json to decide which
architecture + runtime combination needs to be installed.

With dotnet/arcade#4132 arcade can install
foreign SDKs in separate locations correctly.

This change, suggested by @dougbu, makes arcade always install the
runtime for the local architecture (which means it should work on arm64
and x64) as well as the x86 architecture (skipped on Linux).

This gets us a working SDK/Runtime combo on arm64.
@omajid
Copy link
Member Author

omajid commented Oct 31, 2019

@dougbu Does this change look okay to you?

@pranavkm
Copy link
Contributor

pranavkm commented Nov 1, 2019

@omajid @dougbu's out this week. Might be a few more days until this gets seen.

@dougbu
Copy link
Member

dougbu commented Nov 1, 2019

@aspnet-hello
Copy link

This comment was made automatically. If there is a problem contact aspnetcore-build@microsoft.com.

I've triaged the above build. I've created/commented on the following issue(s)
https://github.com/aspnet/AspNetCore-Internal/issues/3327

Copy link
Member

@dougbu dougbu left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

@omajid this looks good. Much appreciated!

I'll merge once the required builds pass.

@dougbu dougbu merged commit c3e5bfd into dotnet:master Nov 2, 2019
omajid added a commit to omajid/dotnet-aspnetcore that referenced this pull request Nov 11, 2019
This commit allows ASP.NET Core to be built on arm64 machines directly,
without relying on cross-compilation.

There's a few changes in here:

1. Ask msbuild to look into the BuildArchitecture

   By default, our build systems assums the machine is x64. This
   modifies the build configuration to check the architecture of the
   currently running build machine, and set BuildArchitecture to that.

2. Fix crossgen in Microsoft.AspNetCore.App.Runtime

   We run crossgen for supported architectures (including x64 and
   arm64). For that, we need a jit that we can point crossgen to.
   Generally, we can rely on the build scripts to find the right
   `libclrjit.so`. However, arm64 has multiple `libclirjit.so`, for
   different use-cases. There's one for arm64 (for running on arm64) and
   there's another one for cross-compiling for arm64 on x64. We need to
   figure out and use the right one explicitly rather than assuming the
   right one gets picked up.

   See dotnet/core-setup#8468 for similar
   changes made in core-setup.

This also needs dotnet#14790 to fully
work on arm64.
JunTaoLuo pushed a commit that referenced this pull request Nov 11, 2019
This commit allows ASP.NET Core to be built on arm64 machines directly,
without relying on cross-compilation.

There's a few changes in here:

1. Ask msbuild to look into the BuildArchitecture

   By default, our build systems assums the machine is x64. This
   modifies the build configuration to check the architecture of the
   currently running build machine, and set BuildArchitecture to that.

2. Fix crossgen in Microsoft.AspNetCore.App.Runtime

   We run crossgen for supported architectures (including x64 and
   arm64). For that, we need a jit that we can point crossgen to.
   Generally, we can rely on the build scripts to find the right
   `libclrjit.so`. However, arm64 has multiple `libclirjit.so`, for
   different use-cases. There's one for arm64 (for running on arm64) and
   there's another one for cross-compiling for arm64 on x64. We need to
   figure out and use the right one explicitly rather than assuming the
   right one gets picked up.

   See dotnet/core-setup#8468 for similar
   changes made in core-setup.

This also needs #14790 to fully
work on arm64.
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 12, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 12, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 12, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 12, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 15, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 15, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 15, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 15, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 15, 2019
This chnage allows source-build to be cloned and built on arm64
 machines. I have tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests
 which have been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 16, 2019
This chnage allows source-build to be cloned and built on arm64
machines. It shouldn't affect cross compilation at all, however. I have
tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests which have
been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453

To support using darc on arm64, this commit removes the customizations
of LD_LIBRARY_PATH and instead forces darc to run again a .NET Core 3.0
runtime. This in-turn makes darc pick up the right libgit2sharp
automatically for the right set of platforms and architectures.

There's a number of existing build configuration that are
conditionalized on arm64, such as setting up a root file system. Those
they are actually only meant to be invoked when cross-compiling for
arm64 (on x86_64). This commit modifies those conditions to not apply
when building on an arm64 machine.
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 20, 2019
This change allows source-build to be cloned and built on arm64
machines. It shouldn't affect cross compilation at all, however. I have
tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests which have
been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453

There's a number of existing build configuration that are
conditionalized on arm64, such as setting up a root file system. Those
they are actually only meant to be invoked when cross-compiling for
arm64 (on x86_64). This commit modifies those conditions to not apply
when building on an arm64 machine.
omajid added a commit to omajid/dotnet-source-build that referenced this pull request Nov 21, 2019
This change allows source-build to be cloned and built on arm64
machines. It shouldn't affect cross compilation at all, however. I have
tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests which have
been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453

There's a number of existing build configuration that are
conditionalized on arm64, such as setting up a root file system. Those
they are actually only meant to be invoked when cross-compiling for
arm64 (on x86_64). This commit modifies those conditions to not apply
when building on an arm64 machine.
crummel pushed a commit to omajid/dotnet-source-build that referenced this pull request Nov 22, 2019
This change allows source-build to be cloned and built on arm64
machines. It shouldn't affect cross compilation at all, however. I have
tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests which have
been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453

There's a number of existing build configuration that are
conditionalized on arm64, such as setting up a root file system. Those
they are actually only meant to be invoked when cross-compiling for
arm64 (on x86_64). This commit modifies those conditions to not apply
when building on an arm64 machine.
crummel pushed a commit to dotnet/source-build that referenced this pull request Nov 24, 2019
* Enable building on arm64

This change allows source-build to be cloned and built on arm64
machines. It shouldn't affect cross compilation at all, however. I have
tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests which have
been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453

There's a number of existing build configuration that are
conditionalized on arm64, such as setting up a root file system. Those
they are actually only meant to be invoked when cross-compiling for
arm64 (on x86_64). This commit modifies those conditions to not apply
when building on an arm64 machine.

* Patch fixup.
MichaelSimons pushed a commit to dotnet/source-build-externals that referenced this pull request Feb 8, 2022
* Enable building on arm64

This change allows source-build to be cloned and built on arm64
machines. It shouldn't affect cross compilation at all, however. I have
tested this on RHEL 8 aarch64.

This change includes backports of the following pull-requests which have
been merged into their respective master branches:

- dotnet/aspnetcore#14790
- dotnet/aspnetcore#15354
- dotnet/installer#4102
- dotnet/core-setup#8468
- dotnet/corefx#40453

There's a number of existing build configuration that are
conditionalized on arm64, such as setting up a root file system. Those
they are actually only meant to be invoked when cross-compiling for
arm64 (on x86_64). This commit modifies those conditions to not apply
when building on an arm64 machine.

* Patch fixup.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
area-infrastructure Includes: MSBuild projects/targets, build scripts, CI, Installers and shared framework
Projects
None yet
Development

Successfully merging this pull request may close these issues.

6 participants