Skip to content

Commit

Permalink
parent 77fba3b
Browse files Browse the repository at this point in the history 
author Stephen Toub <[email protected]> 1604601164 -0500
committer Tammy Qiu <[email protected]> 1604960878 -0500

Add stream conformance tests for TranscodingStream (dotnet#44248)

* Add stream conformance tests for TranscodingStream

* Special-case 0-length input buffers to TranscodingStream.Write{Async}

The base implementation of Encoder.Convert doesn't like empty inputs.  Regardless, if the input is empty, we can avoid a whole bunch of unnecessary work.

JIT: minor inliner refactoring (dotnet#44215)

Extract out the budget check logic so it can vary by inlining policy.
Use this to exempt the FullPolicy from budget checking.

Fix inline xml to dump the proper (full name) hash for inlinees.

Update range dumper to dump ranges in hex.

Remove unused QCall for WinRTSupported (dotnet#44278)

ConcurrentQueueSegment allows spinning threads to sleep. (dotnet#44265)

* Allow threads to sleep when ConcurrentQueue has many enqueuers/dequeuers.

* Update src/libraries/System.Private.CoreLib/src/System/Collections/Concurrent/ConcurrentQueueSegment.cs

Co-authored-by: Stephen Toub <[email protected]>

* Apply suggestions from code review

Co-authored-by: Stephen Toub <[email protected]>

Co-authored-by: AMD DAYTONA EPYC <[email protected]>
Co-authored-by: Stephen Toub <[email protected]>

File.Exists() is not null when true (dotnet#44310)

* File.Exists() is not null when true

* Fix compile

* Fix compile 2

[master][watchOS] Add simwatch64 support (dotnet#44303)

Xcode 12.2 removed 32 bits support for watchOS simulators, this PR helps to fix xamarin/xamarin-macios#9949, we have tested the new binaries and they are working as expected

![unknown](https://user-images.githubusercontent.com/204671/98253709-64413200-1f49-11eb-9774-8c5aa416fc57.png)

Co-authored-by: dalexsoto <[email protected]>

Implementing support to Debugger::Break. (dotnet#44305)

Set fgOptimizedFinally flag correctly (dotnet#44268)

- Initialize to 0 at compiler startup
- Set flag when finally cloning optimization kicks in

Fixes non-deterministic generation of nop opcodes into ARM32 code

Forbid `- byref cnst` -> `+ (byref -cnst)` transformation. (dotnet#44266)

* Add a repro test.

* Forbid the transformation for byrefs.

* Update src/coreclr/src/jit/morph.cpp

Co-authored-by: Andy Ayers <[email protected]>

* Update src/coreclr/src/jit/morph.cpp

* Fix the test return value.

WriteLine is just to make sure we don't delete the value.

* improve the test.

avoid a possible overflow and don't waste time on printing.

Co-authored-by: Andy Ayers <[email protected]>

Pick libmonosgen-2.0.so from cmake install directory instead of .libs (dotnet#44291)

This aligns Linux with what we already do for all the other platforms.

Update SharedPerformanceCounter assert (dotnet#44333)

Remove silly ToString in GetCLRInstanceString (dotnet#44335)

Use targetPlatformMoniker for net5.0 and newer tfms (dotnet#43965)

* Use targetPlatformMoniker for net5.0 and newer tfms

* disabling analyzer, update version to 0.0, and use new format.

* update the targetFramework.sdk

* removing supportedOS assembly level attribute

* fix linker errors and addressing feedback

* making _TargetFrameworkWithoutPlatform as private

[sgen] Add Ward annotations to sgen_get_total_allocated_bytes (dotnet#43833)

Attempt to fix https://jenkins.mono-project.com/job/test-mono-mainline-staticanalysis/

Co-authored-by: lambdageek <[email protected]>

[tests] Re-enable tests fixed by dotnet#44081 (dotnet#44212)

Fixes
mono/mono#15030 and
fixes mono/mono#15031 and
fixes mono/mono#15032

Add an implicit argument coercion check. (dotnet#43386)

* Add `impCheckImplicitArgumentCoercion`.

* Fix tests with type mismatch.

* Try to fix VM signature.

* Allow to pass byref as native int.

* another fix.

* Fix another IL test.

[mono] Change CMakelists.txt "python" -> Python3_EXECUTABLE (dotnet#44340)

Debian doesn't install a "python" binary for python3.

Tweak StreamConformanceTests for cancellation (dotnet#44342)

- Avoid unnecessary timers
- Separate tests for precancellation, ReadAsync(byte[], ...) cancellation, and ReadAsync(Memory, ...) cancellation

Use Dictionary for underlying cache of ResourceSet (dotnet#44104)

Simplify catch-rethrow logic in NetworkStream (dotnet#44246)

A follow-up on dotnet#40772 (comment), simplifies and harmonizes the way we wrap exceptions into IOException. Having one catch block working with System.Exception seems to be enough here, no need for specific handling of SocketException.

Simple GT_NEG optimization for dotnet#13837 (dotnet#43921)

* Simple arithmetic optimization with GT_NEG

* Skip GT_NEG optimization when an operand is constant. Revert bitwise rotation pattern

* Fixed Value Numbering assert

* Cleaned up code and comments for simple GT_NEG optimization

* Formatting

Co-authored-by: Julie Lee <[email protected]>

[master] Update dependencies from mono/linker (dotnet#44322)

* Update dependencies from https://github.com/mono/linker build 20201105.1

Microsoft.NET.ILLink.Tasks
 From Version 6.0.0-alpha.1.20527.2 -> To Version 6.0.0-alpha.1.20555.1

* Update dependencies from https://github.com/mono/linker build 20201105.2

Microsoft.NET.ILLink.Tasks
 From Version 6.0.0-alpha.1.20527.2 -> To Version 6.0.0-alpha.1.20555.2

* Disable new optimization for libraries mode (it cannot work in this mode)

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>
Co-authored-by: Marek Safar <[email protected]>

Tighten argument validation in StreamConformanceTests (dotnet#44326)

Add threshold on number of files / partition in SPMI collection (dotnet#44180)

* Add check for files count

* Fix the OS check

* decrese file limit to 1500:

* misc fix

* Do not upload to azure if mch files are zero size

Fix ELT profiler tests (dotnet#44285)

[master] Update dependencies from dotnet/arcade dotnet/llvm-project dotnet/icu (dotnet#44336)

[master] Update dependencies from dotnet/arcade dotnet/llvm-project dotnet/icu

 - Merge branch 'master' into darc-master-2211df94-2a02-4c3c-abe1-e3534e896267

Fix Send_TimeoutResponseContent_Throws (dotnet#44356)

If the client times out too quickly, the server may never have a connection to accept and will hang forever.

Match CoreCLR behaviour on thread start failure (dotnet#44124)

Co-authored-by: Aleksey Kliger (λgeek) <[email protected]>

Add slash in Windows SoD tool build (dotnet#44359)

* Add slash in Windows SoD tool build

* Update SoD search path to match output dir

* Fixup dotnet version

* Remove merge commit headers

* Disable PRs

Co-authored-by: Drew Scoggins <andrew.g.scoggins@gmail>

Reflect test path changes in .gitattributes; remove nonexistent files (dotnet#44371)

Bootstrapping a test for R2RDump (dotnet#42150)

Improve performance of Enum's generic IsDefined / GetName / GetNames (dotnet#44355)

Eliminates the boxing in IsDefined/GetName/GetValues, and in GetNames avoids having to go through RuntimeType's GetEnumNames override.

clarify http version test (dotnet#44379)

Co-authored-by: Geoffrey Kizer <[email protected]>

Update dependencies from https://github.com/mono/linker build 20201106.1 (dotnet#44367)

Microsoft.NET.ILLink.Tasks
 From Version 6.0.0-alpha.1.20555.2 -> To Version 6.0.0-alpha.1.20556.1

Co-authored-by: dotnet-maestro[bot] <dotnet-maestro[bot]@users.noreply.github.com>

Disable RunThreadLocalTest8_Values on Mono (dotnet#44357)

* Disable RunThreadLocalTest8_Values on Mono

It's failing on SLES

* fix typo

LongProcessNamesAreSupported: make test work on distros where sleep is a symlink/script (dotnet#44299)

* LongProcessNamesAreSupported: make test work on distros where sleep is a symlink/script

* PR feedback

Co-authored-by: Stephen Toub <[email protected]>

* fix compilation

Co-authored-by: Stephen Toub <[email protected]>

add missing constructor overloads (dotnet#44380)

Co-authored-by: Geoffrey Kizer <[email protected]>

change using in ConnectCallback_UseUnixDomainSocket_Success (dotnet#44366)

Clean up the samples (dotnet#44293)

Update dotnet/roslyn issue link

Delete stale comment about dotnet/roslyn#30797

Fix/remove TODO-NULLABLEs (dotnet#44300)

* Fix/remove TODO-NULLABLEs

* remove redundant !

* apply Jozkee's feedback

* address feedback

Update glossary (dotnet#44274)

Co-authored-by: Juan Hoyos <[email protected]>
Co-authored-by: Stephen Toub <[email protected]>
Co-authored-by: Günther Foidl <[email protected]>

Add files need for wasm executable relinking/aot to the wasm runtime pack. (dotnet#43785)

Co-authored-by: Alexander Köplinger <[email protected]>

Move some more UnmanagedCallersOnly tests to IL now that they're invalid C# (dotnet#43366)

Fix C++ build for mono/metadata/threads.c (dotnet#44413)

`throw` is a reserved keyword in C++.

Disable a failing test. (dotnet#44404)

Change async void System.Text.Json test to be async Task (dotnet#44418)

Improve crossgen2 comparison jobs (dotnet#44119)

- Fix compilation on unix platforms
  - Wrap use of wildcard in quotes
- Print better display name into log
- Fix X86 constant comparison handling
- Add ability to compile specific overload via single method switches

Remove some unnecessary GetTypeInfo usage (dotnet#44414)

Fix MarshalTypedArrayByte and re-enable it. Re-enable TestFunctionApply
  • Loading branch information
@stephentoub @tqiu8
stephentoub authored and tqiu8 committed Nov 9, 2020
1 parent 8f322d9 commit a5eb5ea
Show file tree
Hide file tree
Showing 116 changed files with 1,358 additions and 782 deletions.
15 changes: 6 additions & 9 deletions .gitattributes
View file
Original file line number Diff line number Diff line change
Expand Up @@ -69,12 +69,9 @@
# CLR specific
src/coreclr/src/pal/tests/palsuite/paltestlist.txt text eol=lf
src/coreclr/src/pal/tests/palsuite/paltestlist_to_be_reviewed.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regexdna/regexdna-input25000.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regex-redux/regexdna-input25.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/regex-redux/regexdna-input25000.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/reverse-complement/revcomp-input25.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/reverse-complement/revcomp-input25000.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input.txt text eol=lf
src/coreclr/tests/src/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input-big.txt text eol=lf
src/coreclr/tests/src/performance/Scenario/JitBench/Resources/word2vecnet.patch text eol=lf
src/tests/JIT/Performance/CodeQuality/BenchmarksGame/regex-redux/regexdna-input25.txt text eol=lf
src/tests/JIT/Performance/CodeQuality/BenchmarksGame/regex-redux/regexdna-input25000.txt text eol=lf
src/tests/JIT/Performance/CodeQuality/BenchmarksGame/reverse-complement/revcomp-input25.txt text eol=lf
src/tests/JIT/Performance/CodeQuality/BenchmarksGame/reverse-complement/revcomp-input25000.txt text eol=lf
src/tests/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input.txt text eol=lf
src/tests/JIT/Performance/CodeQuality/BenchmarksGame/k-nucleotide/knucleotide-input-big.txt text eol=lf
204 changes: 63 additions & 141 deletions docs/project/glossary.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,9 +14,11 @@ terminology.
| AOT | Ahead-of-time compiler. Converts the MSIL bytecode to native machine code for a specific target CPU architecture. |
| BBT | Microsoft internal early version of C/C++ PGO. See https://www.microsoft.com/windows/cse/bit_projects.mspx. |
| BOTR | Book Of The Runtime. |
| BCL | Base Class Library. A set of `System.*` (and to a limited extent `Microsoft.*`) libraries that make up the lower layer of the .NET library stack. |
| CLR | Common Language Runtime. |
| COMPlus | An early name for the .NET platform, back when it was envisioned as a successor to the COM platform (hence, "COM+"). Used in various places in the CLR infrastructure, most prominently as a common prefix for the names of internal configuration settings. Note that this is different from the product that eventually ended up being named [COM+](https://msdn.microsoft.com/en-us/library/windows/desktop/ms685978.aspx). |
| COR | [Common Object Runtime](http://www.danielmoth.com/Blog/mscorlibdll.aspx). The name of .NET before it was named .NET. |
| CoreFX | Core Framework. Original project name for open source and cross-platform version of [.NET runtime libraries](https://github.com/dotnet/runtime/tree/master/src/libraries) |
| DAC | Data Access Component. An abstraction layer over the internal structures in the runtime. |
| EE | Execution Engine. |
| GC | [Garbage Collector](https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/botr/garbage-collection.md). |
Expand Down Expand Up @@ -71,29 +73,6 @@ In this document, the following terms are used:
different implementations. For instance, our vector library relies on the JIT
to use the highest available SIMD instruction set.

* **AOT**. Ahead of time compiler. Similar to JIT, this compiler also translates
IL to machine code. In contrast to JIT compilation, AOT compilation happens
before the application is executed and is usually performed on a different
machine. AOT tool chains don't trade runtime for compile time and thus can
spend more time optimizing. Since the context of AOT is the entire
application, the AOT compiler can also perform cross module linking and whole
program analysis, which means that all references are followed and a single
executable is produced.

* **NGEN**. Native (image) generation. You can think of this technology as a
persistent JIT compiler. It usually compiles code on the machine where the
code will be executed, but compilation typically occurs at install time.

* **CoreFX**. Core framework. Conceptually a set of `System.*` (and to a limited
extent `Microsoft.*`) libraries that make up the lower layer of the .NET
library stack. It's what most people would think of as the Base Class Library
(BCL). The BCL is a general purpose, lower level set of functionality that
higher-level frameworks, such as WCF and ASP.NET, build on. The source code of
the .NET Core library stack is contained in the [CoreFX repo][corefx].
However, the majority of the .NET Core APIs are also available in the .NET
Framework, so you can think of CoreFX as a fork of the .NET Framework library
stack.

* **CLI**. Command Line Interface --or-- Common Language Infastructure.
* Command Line Interface: A tool that has no graphical interface and is
intended to be used completely from a console/terminal. Also is commonly
Expand All @@ -103,114 +82,30 @@ In this document, the following terms are used:
[ECMA-355][ECMA-355].

* **CLR**. Common Language Runtime: The runtime/environment that .NET code
executes in. Is also commonly used to refer to the Microsoft Windows only
implementation

## Runtimes

### Common Language Runtime

**Also referred to as**: CLR, VM, runtime

The CLR is a virtual machine, i.e. it includes the facilities to generate and
compile code on-the-fly using a JIT compiler. The existing Microsoft CLR
implementation is Windows only.
executes in. It is also commonly used to refer to the Microsoft .NET Framework
Windows-only implementation.

### Core Common Language Runtime
## .NET Runtimes

**Also referred to as**: CoreCLR, VM, runtime
### .NET Core / .NET

It's built from the same code base as the CLR. Originally, CoreCLR was the
runtime of Silverlight and was designed to run on multiple platforms,
specifically Windows and OS X. CoreCLR is now part of .NET Core and represents a
simplified version of the CLR. It's still a [cross platform][core-build-status]
runtime. CoreCLR is also a virtual machine with a JIT.
.NET Core has been the name for the open source, cross-platform stack that
ASP.NET Core and UWP applications are built on. For more details,
read [Introducing .NET Core][introducing-net-core].

### Core Runtime

**Also referred to as**: CoreRT

In contrast to the CLR/CoreCLR, CoreRT is not a virtual machine, i.e. it doesn't
include the facilities to generate and run code on-the-fly because it doesn't
include a JIT. It does, however, include the GC and the ability for runtime type
identification (RTTI) as well as reflection. However, its type system is
designed so that metadata for reflection can be omitted. This enables having an
AOT tool chain that can link away superfluous metadata and (more importantly)
identify code that the application doesn't use.

## Platforms
.NET Core has become future of the platform, and we refer to it just as .NET today.
For more details, read [Introducing .NET 5][introducing-net-5].

### .NET Framework

**Also referred to as**: Desktop, full framework, in-box framework, ~~CLR~~
**Also referred to as**: Desktop, full framework

This refers to the .NET Framework that first shipped in 2002 and has been
updated on a regular basis since then. It's the main framework folks target
today and allows you to build a wide variety of applications, such as WinForms,
WPF, ASP.NET, and command line tools.
.NET Framework was the very first .NET runtime. It first shipped in 2002, and it has been
updated on a regular basis since then.

The .NET Framework was designed to run on Windows only. Some versions of the
.NET Framework come pre-installed with Windows, some require to be installed.
However, in both cases the .NET Framework is a system-wide component.
Applications do not include .NET Framework DLLs when deploying; the correct .NET
version must be on the machine.

### .NET Core

**Also referred to as**: UWP, ~~Store~~

Originally, .NET Core was the identifier we used to describe the .NET APIs
Windows 8 store applications could use. When we designed the API set, we wanted
to create a foundation for .NET where portability is a first class concern for
the layering and componentization. For more details, read [this blog
post][introducing-net-core].

Today, .NET Core is no longer just for store applications. .NET Core is the name
for the open source, cross-platform stack that ASP.NET Core and UWP applications
are built on. The stack includes a set of framework libraries (CoreFX), a JIT
based runtime (CoreCLR), an AOT based runtime (CoreRT), and a set of tooling
(such as the dotnet CLI).

That's why referring to .NET Core as 'Store' is no longer correct. But you can
think of today's .NET Core as an evolution of the original APIs available for
store applications. Many of the original design goals are still relevant,
especially around layering and portability.

### Universal Windows Platform (UWP)

**Also referred to as**: Store, WinRT, Metro

The Universal Windows Platform (UWP) is the platform that is used for building
modern, touch-enabled Windows applications as well as headless devices for
Internet of Things (IoT). It's designed to unify the different types of devices
that you may want to target, including PCs, tablets, phablets, phones, and even
the Xbox.

UWP provides many services, such as a centralized app store, an execution
environment (AppContainer), and a set of Windows APIs to use instead of Win32
(WinRT). UWP has no dependency on .NET; apps can be written in C++, C#, VB.NET,
and JavaScript. When using C# and VB.NET the .NET APIs are provided by .NET
Core.

**Also referred to as**: ahead-of-time (AOT), IL compiler (ILC)

.NET Native is a compiler tool chain that will produce native code ahead-of-time
(AOT), as opposed to just-in-time (JIT). The compilation can happen on the
developer machine as well as on the store side, which allows blending AOT with
the benefits of servicing.

You can think of .NET Native as an evolution of NGEN (Native Image Generator):
NGEN basically simply runs the JIT up front, the code quality and behavior is
identical to the JITed version. Another downside of NGEN is that it happens on
the user's machine, rather than the developer's machine. NGEN is also at the
module level, i.e. for each MSIL assembly there is a corresponding NGEN'ed
assembly that contains the native code. .NET Native on the other hand is a C++
like compiler and linker. It will remove unused code, spend more time optimizing
it, and produce a single, merged module that represents the closure of the
application.

UWP was the first application model that was supported by .NET Native. We now
also support building native console applications for Windows, OS X and Linux.

### Rotor

Expand All @@ -232,34 +127,61 @@ officially updated since .NET Framework 2.0.

### Mono

Mono is an open source alternative to the .NET Framework. Mono started around
[Mono][mono] is an open source alternative to the .NET Framework. Mono started around
the same time the .NET Framework was first released. Since Microsoft didn't
release Rotor as open source, Mono was forced to start from scratch and is thus
release Rotor as open source, Mono was forced to start from scratch and was thus
a complete re-implementation of the .NET Framework with no shared code.

When .NET Core was released under the MIT license, Microsoft also released large
chunks of the .NET Framework under the MIT license as well, which can be found
[here][referencesource]. This enabled the Mono community to use the same code
the .NET Framework uses in order to close gaps and avoid behavioral differences.
Today, the [Mono VM](https://github.com/dotnet/runtime/tree/master/src/mono) is part
of the unified .NET platform. It is optimized for mobile (e.g. Xamarin) and browser (e.g. Blazor) scenarios.

"C# powered by Mono" has been scripting engine of choice for a number of game engines.
Unity - the world's most popular game engine - is scripted by C#, powered by a customized Mono runtime.

### CoreCLR

Originally, CoreCLR was the runtime of Silverlight and was designed to run on multiple
platforms, specifically Windows and OS X.

Today, the [CoreCLR runtime](https://github.com/dotnet/runtime/tree/master/src/coreclr)
is part of unified .NET platform. It is optimized for cloud (e.g. ASP.NET) and
desktop (e.g. WinForms, WPF) scenarios.

## Ahead-Of-Time Compilation (AOT)

Most flavors of .NET runtime come with at least partial AOT compilation. A variety of AOT technologies
with unique characteristics were developed for .NET runtimes over the years.

### ReadyToRun

**Also referred to as**: R2R

[ReadyToRun](.../design/coreclr/botr/readytorun-overview.md)
is a file format used by the CoreCLR runtime to store AOT compiled code. `crossgen` is the AOT compiler that
produces binaries in the ReadyToRun file format.

### NGen

[NGen](https://docs.microsoft.com/en-us/dotnet/framework/tools/ngen-exe-native-image-generator)
is AOT technology included in .NET Framework. It usually compiles code at install time on the machine where
the code will be executed.

### Full AOT

Mono is primarily used to run .NET applications on Linux and macOS (though to
get into the Mac App Store you need Xamarin, see below). There are ports of Mono
to other platforms, see [Mono's Supported Platforms][mono-supported-platforms]
[Full AOT](https://docs.microsoft.com/en-us/xamarin/ios/internals/architecture) is used
by Mono runtime in environments that prohibit fallback to JIT.

Mono has implementations (though not necessarily complete) of WinForms, ASP.NET,
and System.Drawing.
### Hybrid AOT

### Xamarin
[Hybrid AOT](https://docs.microsoft.com/en-us/xamarin/mac/internals/aot#hybrid-aot) is used
by Mono runtime in environments that allow fallback to JIT or need IL interpreter.

Xamarin is a commercial offering for building mobile applications targeting
Android, iOS and Mac OS X Store. It's based on Mono, and on iOS and Android
surfaces a different API profile, called the mobile profile. The subsetting was
necessary to reduce the footprint, both by shipping smaller versions of the
system libraries as well as making them more linker friendly. While Mono runs on
macOS without Xamarin, their linker is required make the app package for the
Mac App Store. Xamarin ships a full static compiler on iOS, as the platform
does not support dynamic code generation.
### Native AOT

[Native AOT](https://github.com/dotnet/designs/blob/main/accepted/2020/form-factors.md#native-aot-form-factors) is
a .NET runtime form factor with key performance characteristics (startup time, binary size and steady state throughput and predictability)
competitive with statically compiled languages. A .NET runtime flavor based on CoreCLR with these characteristics is being developed as
experimental project in [dotnet/runtimelab](https://github.com/dotnet/runtimelab/tree/feature/NativeAOT) repo.

## Frameworks

Expand Down Expand Up @@ -346,8 +268,8 @@ and enabling support for running WPF on .NET Core (Windows Only).


[introducing-net-core]: https://devblogs.microsoft.com/dotnet/introducing-net-core/
[core-build-status]: https://github.com/dotnet/coreclr#build-status
[corefx]: http://github.com/dotnet/corefx
[introducing-net-5]: https://devblogs.microsoft.com/dotnet/introducing-net-5/
[mono]: http://github.com/mono/mono
[referencesource]: https://github.com/microsoft/referencesource
[mono-supported-platforms]: http://www.mono-project.com/docs/about-mono/supported-platforms/
[mono-winforms]: http://www.mono-project.com/docs/gui/winforms/
Expand Down
11 changes: 6 additions & 5 deletions eng/BeforeTargetFrameworkInference.targets
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,17 +3,18 @@
<PropertyGroup Condition="$(TargetFramework.Contains('-'))">
<_OriginalTargetFramework>$(TargetFramework)</_OriginalTargetFramework>
<TargetFrameworkSuffix>$(TargetFramework.SubString($([MSBuild]::Add($(TargetFramework.IndexOf('-')), 1))))</TargetFrameworkSuffix>
<TargetFramework>$(TargetFramework.SubString(0, $(TargetFramework.IndexOf('-'))))</TargetFramework>
<!-- Strip away the TargetPlatform during the build for frameworks older than net5.0 because the assets file does not know about the TargetPlatform -->
<TargetFramework>$([System.Text.RegularExpressions.Regex]::Replace('$(TargetFramework)', '$(TargetFrameworkPattern)', '${1}'))</TargetFramework>
</PropertyGroup>

<Import Project="$(MSBuildThisDirectory)targetframeworksuffix.props" Condition="'$(DesignTimeBuild)' == 'true'" />

<PropertyGroup>
<IntermediateOutputPath>$([MSBuild]::NormalizeDirectory('$(BaseIntermediateOutputPath)', '$(TargetFramework)-$(TargetFrameworkSuffix)-$(Configuration)'))</IntermediateOutputPath>
<IntermediateOutputPath Condition="'$(TargetFrameworkSuffix)' == ''">$([MSBuild]::NormalizeDirectory('$(BaseIntermediateOutputPath)', '$(TargetFramework)-$(Configuration)'))</IntermediateOutputPath>
<IntermediateOutputPath>$([MSBuild]::NormalizeDirectory('$(BaseIntermediateOutputPath)', '$(TargetFramework)-$(Configuration)'))</IntermediateOutputPath>
<IntermediateOutputPath Condition="'$(TargetFrameworkSuffix)' != '' and !$(TargetFramework.Contains('-'))">$([MSBuild]::NormalizeDirectory('$(BaseIntermediateOutputPath)', '$(TargetFramework)-$(TargetFrameworkSuffix)-$(Configuration)'))</IntermediateOutputPath>
<!-- setting the output paths -->
<OutputPath>$([MSBuild]::NormalizeDirectory('$(BaseOutputPath)', '$(TargetFramework)-$(TargetFrameworkSuffix)-$(Configuration)'))</OutputPath>
<OutputPath Condition="'$(TargetFrameworkSuffix)' == ''">$([MSBuild]::NormalizeDirectory('$(BaseOutputPath)', '$(TargetFramework)-$(Configuration)'))</OutputPath>
<OutputPath>$([MSBuild]::NormalizeDirectory('$(BaseOutputPath)', '$(TargetFramework)-$(Configuration)'))</OutputPath>
<OutputPath Condition="'$(TargetFrameworkSuffix)' != '' and !$(TargetFramework.Contains('-'))">$([MSBuild]::NormalizeDirectory('$(BaseOutputPath)', '$(TargetFramework)-$(TargetFrameworkSuffix)-$(Configuration)'))</OutputPath>
</PropertyGroup>

</Project>
Loading

0 comments on commit a5eb5ea

Please sign in to comment.