* Remove dotnet6 feeds

dotnet7 feeds are currently the target feeds for the main branch. The dotnet6 feeds shouldn't be used anymore.

* Update targetingpacks.targets

* Update prebuilt package versions

* Update NativeExports.csproj

This was originally done in mono/mono to allow building both legacy and netcore, but we don't need this split anymore in dotnet/runtime.

#66750)

* Preliminary changes

* Add the missing push of ssadef

* Fix an issue for call tree cloning

* formatting

* minor review comments incorporation

* Make GT_CALL as full-def

* Merge RenameCall into RenameDef

* Fix DefinesLocalAddr and lateuse arg

* Minor comments

* fix the recently added code to account that GT_CALL can also have defintion:

* clone the return buffer arg

* Another round of review comments

* Handle return buffer calls in optIsVarAssgCB

* Update locals defined by calls in NodeInfo

* Fix a case where arg can be putarg

* Restructure the cases in GetLclRetBufArgNode()

* move ivaMaskCall outside the condition

* Add back to call for DoNotEnregister which was missed for Release builds

* Retrieve the appropriate node in case of copyReload

* Added an assert

* remove assert and add comment

…ExceptionContainsHostInfo on OSX (#66761)

…gging (#66677)

* Use managed sourcelink infrastructure to allow for win native sourcelink

The additional trace should help troubleshoot hanged "pending" connection issues (i.e. the reasons why new connections were not created) in HttpConnectionPool.

The issue manifests as growing number of timeouted requests. It is not easy to link a timeouted request (esp. with a small timeout) to a connection that was created 3 minutes ago but still is not connected. There are no traces of the state of HttpConnectionPool, e.g. number of pending connections, so it is unclear from existing traces why the pool decided not to create a connection.

Related to #66297

…gging managed code (#64223)

* Show the callstack as it's shown on net5.

* Addressing @lewing and @radical comments.

* addressing @lewing comment.

#66295)

* Fix incompatibility between runtime and nuget package

* Update debug.ts

…ossible (#66748)

* Updating generic math interfaces to be implicitly implemented where possible

* Resolve a build error in OdbcConnection caused by new Parse APIs

* Revert "Resolve a build error in OdbcConnection caused by new Parse APIs"

This reverts commit 6fd7ec7.

* Suppress CA1846 for System.Data.Odbc

* Updating the xml doc comments for exposed constants

…ws (#66666)

* Always append the "dll" extension for native libraries loads on Windows

Due to case-sensitive file systems on Windows the runtime will now
  always append the ".dll" extension unless the name contains a trailing
  "." or a known loadable extensions. This is an attempt to mitigate
  the default Windows behavior that appends a ".DLL" which is rarely the
  casing used for Windows shared libraries.

Co-authored-by: Jan Kotas <[email protected]>

* Reimplement stubs to improve performance

This change implements `FixupPrecodeStub`, `PrecodeStub`
and `CallCountingStub` using a new mechanism with fixed code and separate RW
data. The `LoaderHeap` was updated to support a new kind of allocation
using interleaved code and data pages to support this new mechanism.
The JIT now generates code that uses indirection slot to jump to the
methods using `FixupPrecode`, improving performance of the ASPNet
plaintext benchmark by 3-4% depending on the target platform (measured
on x64 Windows / Linux and arm64 Linux).

I have also removed the Holders, as the stubs are naturally properly
aligned due to the way they are allocated.

There is now only a single variant of each stub, there are no long /
short ones anymore as they are not needed - the indirect jumps we use
now are not range limited.

Most of the stubs stuff is now target agnostic and the originally split
implementation is now in single place for all targets. Only a few
constants are defined as target specific in these.

The code for the stubs is no longer generated as bytes by C++ code, but
rather written in asm and compiled. These precompiled templates are then
used as a source to copy the code from. The x86 is a bit more complex
than that due to the fact that it doesn't support PC relative indirect
addressing, so we need to relocate all access to the data slots when
generating the code pages.

As a further improvement, we could generate just a single page of the
code and then just map it many times. This is left for future work.

ARM64 Unix differs from the other targets / platforms - there are
various page sizes being used. So the asm templates are generated for
4k..64k page sizes and the variant is then picked at runtime based on
the page size extracted from the OS.

This also removes a lot of writeable mappings created for modifications
of the stub code when W^X is enabled, in the plaintext benchmark they
were reduced by 75%. That results in a significant reducing of the .NET
application startup time with W^X enabled.

I think the `LoaderHeap` would benefit from some refactoring, but I'd
prefer leaving it for a follow up. It seems that for the sake of the
review, it is better to keep it as is.

The change also implements logging of number of mappings and their exact
locations. This helped me to drive the work and I am planning to use it
for further changes. It can be removed in the future once we reach a
final state.

There are still opportunities for improvement, but these stubs allowed
me to scrape off the most significant portion of the mappings.

* Implement missing SymUnmanaged* interfaces

* Add try-finally around GCHandle

* Marshal interface argument to pinned pointer

* Minor fixes

* Address feedbacks from review

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