[runtime] Fix DISABLE_REFLECTION_EMIT build.

[runtime] Handle RuntimeWrappedException and dynamic methods using a SRE as module. Fixes #59334

A DynamicMethod can be placed in a SRE module and it must respect any RuntimeCompatibilityAttribute set on that assembly.

We do that by updating the runtime side list of cattr in the AssemblyBuilder when a RuntimeCompatibilityAttribute is set using SetCustomAttribute.

[runtime] Handle RuntimeWrappedException and dynamic methods.

Introduce MonoDynamicMethod that holds the assembly of a DM (and TB).
Use it to determine the RuntimeWrappedException policy for exceptions.

This is needed cuz the assembly of a MonoMethod is normally found using method->parent->image->assembly.

But this doesn't work with DynamicMethods that don't define an owner type as they are forced to corlib's policy.

The default policy for DM's is to not wrap those exceptions and in the case a Module is provided, the policy of that module must be respected.

This commit handles all cases but when a Module is a SRE module.

[profiler] Add dedicated coverage profiler (#5622)

This is to remove the need to depend on the log profiler and mprof-report to generate code coverage reports

[ppc64] add instructions needed for builtin types

[ppc] add native type support for float

[ppc] add native type support for integer

Add test projects (optional) to net_4_x.sln (#5633)

* add tests to net_4_x.sln

* remove redundant string.Format

[jit] Fix constrained calls from gsharedvt methods using an interface type to vtype methods, the receiver is boxed, needs to be unboxed. Fixes #58507. (#5628)

Merge pull request #5594 from BrzVlad/fix-domain-abort-hang

[runtime] AppDomain fixes

[tests] Add tests for AppDomainUnloadedException handling

As described on https://msdn.microsoft.com/en-us/library/system.appdomainunloadedexception(v=vs.110).aspx#Anchor_6

[acceptance-tests] ms-test-suite: move systemruntimebringup tests to NUnit and add System.Linq.Expressions tests (#5624)

This gets rid of compiling ~300 executables which significantly cuts down build time.

Also added the System.Linq.Expressions which were not run before.

Changes: https://github.com/xamarin/ms-test-suite/compare/73c155f76b55839f26ba707d6d40091060e4f5d8...25f495326e141163d59e52ef499227a2f38fe036 (private repo)

[linker-analyzer] added documentation

[tests] Add test for appdomain

Tests that we can unload domain where the threads reset the abort exception and that this exception is converted to AppDomainUnloadedException in the caller domain.

[runtime] Don't terminate application on unhandled AppDomainUnloadedException

Except for threads started by unmanaged code (like the main thread).

[runtime] Throw DomainUnloadedException exception when aborting appdomain thread

Before we were propagating the abort exception down in the calling domain.

[remoting] Refactor xdispatch wrapper to use icall for exception conversion

[runtime] Ignore ResetAbort when the current appdomain is unloading

Fixes #5804

Merge pull request #5620 from mono/bump-bockbuild

Bump bockbuild to get gtk Japanese IME fixes

Bump bockbuild to get gtk Japanese IME fixes

Merge pull request #5608 from mono/xcode9_bockbuild_fix

Update bockbuild for XCode 9 build fix

[threads] Keep the tid after the thread has finished (#5615)

Merge pull request #5614 from alexrp/master

[runtime] Fix shared-only build.

Unlock `mini-trampolines.c`: (#5597)

- have all counters in a global place and initialise them in `mono_trampolines_init ()`
- use `Unlocked* ()` and `mono_trampolines_lock ()` to mark / synchronise all racy counters

[corlib] Fix 44255: Inconsistent results in the serialization of TimeZoneInfo.  (#5576)

[mono-api-html] Print ref/out modifiers on parameters. Fixes #59430.

Print ref/out modifiers on parameters, so that any changes in ref/out are detected.

https://bugzilla.xamarin.com/show_bug.cgi?id=59430

[runtime] Fix shared-only build.

Mark `mono_g_hash_table_max_chain_length` as known and accepted data race (#5520)

[TSan] Unlock mono_g_hash_table_max_chain_length

I would suggest using `Unlocked* ()` here. `mono_g_hash_table_find_slot ()` is called relatively often and, unlike increment or add operations, read and write operations (without a global surrounding lock) do not gain much (if anything) by being interlocked as long as they can be read and written by one instruction. That should be true for 32-bit integers and Mono's supported platforms.

[TSan] Unlock fastpath when checking domains_to_finalize (#5598)

[TSan] Unlock fastpath when checking domains_to_finalize

I understand that the affected line is a fastpath which seems absolutely fine to me as it is properly checked later. It is, however, rightfully, detected as a data race by Clang's ThreadSanitizer. I would, therefore, suggest using `UnlockedReadPointer ()` to mark this race as known + accepted.

Merge pull request #5610 from alexrp/master

[Mono.Profiler.Log] Some performance improvements.

fix for DSA

fix-38054

[Mono.Profiler.Log] Use null references to indicate the absence of names.

[Mono.Profiler.Log] Load entire buffers before processing them.

This should reduce the amount of I/O system calls we do, and should be fine
in terms of memory usage since the profiler tries to keep buffers small (64k),
and latency since the profiler flushes buffers every second.

This changes the API somewhat so that users no longer have to construct a
LogReader; this is now done internally, and the type is no longer public. Also,
the LogProcessor now leaves the given stream open, so it's up to the user to
close it.

[Mono.Profiler.Log] Fix excessive byte array allocations.

The problem was that the base Stream.ReadByte () method allocates a temporary
byte array and then calls Read (..., 1) on it. To solve this, we override
ReadByte () in LogStream and use a private buffer to hold the result.

It's a bit of a mystery to me why Stream.ReadByte () does it this way. The
documentation for Stream explicitly says that instance methods aren't thread
safe, so it would be perfectly fine for Stream.ReadByte () to do what we do
here...

Merge pull request #5528 from rodrmoya/fix-mono-profiler-lib

[Mono.Profiler.Log] Support MLPD version 13

[Mono.Profiler.Log] Styling fixes

Update bockbuild for XCode 9 build fix

[verifier] Allow byref in PropertySig blobs. Fixes #59180

[WindowsBase] Fix exception type in *ValueSerializer.ConvertFromString with null parameter

ArgumentNullException was introduced by https://github.com/mono/mono/pull/5593
but it should be NotSupportedException instead to match with Windows .NET.

Similar change to what was noticed during review of https://github.com/mono/mono/pull/5343#discussion_r132166426.

[WindowsBase] Use InvariantCulture for ConvertTo/ToString tests

They'd fail on locales such as de-DE before which uses ';' as separator.

Merge pull request #5573 from lateralusX/lateralusX/windows-invalid-socket-error

Fix sporadic failures in MonoTests.System.Net.HttpRequestStreamTest on x64 Windows.

Merge pull request #5589 from marek-safar/tests

Update tests network helper to be reliable in multi-threaded tests

[w32error] Add ENXIO -> ERROR_DEV_NOT_EXIST error translation

Context: https://bugzilla.xamarin.com/show_bug.cgi?id=58738

[System.Runtime.Remoting] Adds System.Core reference for tests

Update tests network helper to be reliable in multi-threaded tests

[msvc] Update csproj files (#5602)

Multi-culture implementation ValueSerializers, Parse and ToString for types from WindowsBase. (#5593)

[CI] Update Clang's ThreadSanitizer blacklist (#5558)

* Update clang-thread-sanitizer-blacklist based on races that can occur with commit 20bbf3208687b3f12582a35103bd6a6c9bb8a32e

* Add functions that came up in:
- https://jenkins.mono-project.com/job/test-mono-pull-request-clang-sanitizer/23/
- https://jenkins.mono-project.com/job/test-mono-pull-request-clang-sanitizer/24/
- https://jenkins.mono-project.com/job/test-mono-pull-request-clang-sanitizer/25/
- https://jenkins.mono-project.com/job/test-mono-pull-request-clang-sanitizer/26/

Install Microsoft.FSharp.NetSdk.props and targets (#5581)

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=57771

[mono-api-html] Add solution.

It makes running mono-api-html from an IDE easier.

[llvm] Map byref types to the same type as the this argument so they are called using the same signature if the this argument is passed explicitly. Fixes #59436. (#5572)

[loader] Init MonoClass:sizes.element_size lazily (Fixes #43563) (#5559)

* [loader] If signaling recursive type initialize, don't double free

If we detect that a recursive type initialization is happening, we should leave
without removing the class from the init_pending_tld_id list.  Otherwise we get
a double-free when the outer recursive call finally finishes and tries to
remove the same element.

Also re-load the init_list from TLS since a recursive call to mono_class_init could
have modified it between the time the current mono_class_init call started and
when it is finishing.

* [loader] Improve error message when a field's type is a failed class

Add the class failure to the field failure error message.

* [tests] Check that runtime can represent recursive structs

Regression tests for https://bugzilla.xamarin.com/show_bug.cgi?id=43563

* [loader] Init MonoClass:sizes.element_size lazily (Fixes #43563)

Originally mono_bounded_array_class_get () would populate
MonoClass:sizes.element_size as soon as the MonoClass for the array was needed.
This is a problem because we cannot call mono_class_array_element_size () on
the element class on a valuetype until mono_class_layout_fields () finishes
initializing it.

That means that structs which contain an array of themselves would hit the
recursive initialization check in mono_class_setup_fields and the MonoClass for
the element class would be marked as failed to load.

Instead we rely on the MonoClass:size_inited bit to tell us whether the array
class has been initialized and if not, we set the array element size in
mono_class_layout_fields.

This is possible because MonoClass:sizes.element_size is only really needed to
know how to allocate space for an array.  When laying out a class that contains
an array we don't need the element size - they array is just a reference type.

Example:
```csharp
struct S {
    static S[][] foo;
}
```

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=43563

[interp] disable assemblyresolve_event6.exe

needs working appdomains in the interpreter.

[msbuild] Bump to get workaround for bxc #55697 . (#5591)

https://github.com/mono/msbuild/commit/8b76a1d2b9ffc493349a861962e44540ea14eaac

[SWF] Allow to compile without X11 installed (Xamarin-59496)

This change fixes a crash we get in resgen when building without
X11 installed. The bug got introduced when fixing Xamarin-395.

Change-Id: If81a4a3ca4db7a1b0156480ad49bd61610ecebf0

Update filters for new files added to Visual Studio projects.

Bump API snapshot submodule

[System]: SslStream.Flush() now flushes the underlying stream.  Bug #57528. (#5569)

* Mono.Security.Interface.IMonoSslStream: removed Flush().

* Mono.Net.Security.MobileAuthenticatedStream: Flush() now calls `InnerStream.Flush ()'.

* System.Net.Security.SslStream: Flush() now calls `InnerStream.Flush ()'.

* System.Net.Security.SslStream: fix `CanRead`, `CanWrite` and `CanTimeout` logic.

[Mono.Security]: Add internal 'MonoTlsProviderFactory.InternalVersion' constant. (#5568)

Internal version number (not in any way related to the TLS Version).

Used by the web-tests to check whether the current Mono contains certain
features or bug fixes.

Negative version numbers are reserved for martin work branches.

[Mono.Profiler.Log] Check MLPD version when reading header

Right now, when reading a MLPD of an old version, it just silently fails, so
throw an exception when the version is unsuported.

[Mono.Profiler.Log] Reverse managed backtrace in SampleHitEvent's

This comes in reverse order, compared to other backtraces in the MLPD, so
reverse it before sending it to visitors, so that it comes in the same
format as the rest of backtraces.

Invalid handle exception during WSACleanup on shutdown.

Running the MonoTests.System.Net.HttpRequestStreamTest under debugger reveals this
problem. WSACleanup is freeing an invalid handle as part of network shutdown.

This happens since mono_w32socket_close calls incorrect win32 API when closing sockets.
It currently calls CloseHandle, while it should call closesocket. This probably cause
problems in winsock book keeping of active sockets, and when closing the network layer,
winsock will try to close handles that it still open, but since the handles have already been closed
by incorrect call to CloseHandle, it will close an “invalid handle” either causing the exception
or even worse, close a different handle currently in use, causing undefined behavior
during the rest of mono shutdown.

Fix is to switch to correct API when closing sockets on Windows, closesocket instread of CloseHandle.

Fix sporadic failures in MonoTests.System.Net.HttpRequestStreamTest on x64 Windows.

MonoTests.System.Net.HttpRequestStreamTest suite has sporadic failures on Windows x64
with following exception:

System.Net.Sockets.SocketException : An operation was attempted on something that is not a socket.

This happens due to a data type and constant size mismatch. w32socket.h defines
INVALID_SOCKET and SOCKET_ERROR for all platforms. On Windows x64, SOCKET is defined
by winsock2.h as 64-bit type as well as INVALID_SOCKET constant, but above code will
define INVALID_SOCKET as a 32-bit constant value. This will in turn cause code to sporadically
fail to detect invalid sockets as returned by win32 API's. This will in turn cause the socket
exception when code continues to use socket as argument to win32 socket API’s.

Current “invalid” x64 codegen for expression:

if (sock == INVALID_SOCKET)

mov         eax,0FFFFFFFFh
cmp         rsi,rax

and with fixed defines, correct 64-bit cmp instruction:

cmp         rsi,0FFFFFFFFFFFFFFFFh

Fix makes sure we get the defines of INVALID_SOCKET and SOCKET_ERROR from winsock2.h
on Windows platforms to be consistent with define of SOCKET type.

Fix bug 4786 test.

The fix in #5501 had a scoping error causing `make check` to fail.

[Mono.Profiler.Log] Support MLPD version 13

The differences from v14 are small, and given it is the current "stable"
MLPD version, it's worth supporting it. The differences are:

* ImagePointer field not present in v13 Assembly*Event's
* In MonitorEvent, LogMonitorEvent is not in a separate field, but included
  as a flag in the extType field.
* SampleHitEvent's have a type field in v13, which was removed in v14, because
  only cycles samples are emitted.
* MONO_GC_EVENT_{MARK,RECLAIM}_{START,END} were removed in v14
* SampleUnmanagedBinary's SegmentPointer is not based on ptr_base in v13
* In v13, HeapRootsEvent's Attributes is (wrongly) a byte, in v14 this was
  fixed and changed back to a uleb128

Merge pull request #5562 from alexrp/master

[profiler] Revert the root_type field back to uleb128.

Merge pull request #5550 from Cry-Miron/patch-1

Fix issue where loaded global modules aren't freed

Bump ikdasm

[corlib] Update negative symbol for all cultures. Fixes #57496

Changed indentation to K&R indentation

[Mono.Profiler.Log] Read root type field as uleb128.

[profiler] Revert the root_type field back to uleb128.

It's actually a 32-bit value.

Merge pull request #5544 from kumpera/verify_byref_return

Implement verification of safe byref returns

[msbuild] Bump msbuild to pick up SDK updates (#5548)

[runtime] Use no-op for SufficientExecutionStack on Linux (#5543)

We had previously responded to bad performance on android by stubbing out
ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_SufficientExecutionStack
on android. This was necessary because the call to pthread_attr_getstack ()
will read /proc/self/maps. When used inside of a hot function, the performance is terrible.

Fixes https://bugzilla.xamarin.com/show_bug.cgi?id=58911

[verifier] Add test for structs.

Fix bug 57918:
Async Socket reads that need to perform multiple underlying read operations fail to return a correct total # of bytes read

Mark operations on `shutting_down` as known and accepted data races

[coop handles] Record backtrace when allocating handles when MONO_HANDLE_TRACK_OWNER is defined

A backtrace that leads to the allocation site is helpful for debugging.

[appdomain] Catch exceptions when invoking AppDomain.DoAssemblyResolve

Otherwise we may leak a coop handle for the requesting assembly, which may
lead to an assertion when we unload the current domain.

[test] Regression test for #58950

If a reflection only assembly resolve event handler throws an exception, catch
the exception in the runtime to ensure that no coop handles leak.

Fix assert in module cleanup if nothing is cached

Fix issue where loaded global modules aren't freed

Globally loaded modules would previously call LoadLibrary on Windows, but never FreeLibrary. This would result in said library keeping an internal reference counter of 1 until the application exited its entry-point, resulting in possible shutdown issues.

This commit makes sure that we correctly free modules (and unload them in the platform-specific APIs) whenever Mono itself is shutting down, ensuring the expected result of Mono-loaded libraries being correctly freed.

[verifier] Fail to merge stacks with different safe byref'ness.

[verifier] Implement verification of byref returns.

The verification algorithm is inspired on internal specs by the Roslyn team but adapted to what it generates today.
Here's how this patch works:

We introduce a new verification type, SAFE_BYREF, that's used for a byref value that is safe to return from the stack.

It's unverifiable to return a byref value that is not marked SAFE_BYREF.

We mark the following values are SAFE_BYREF:
- byref arguments, unless it's the `this` arg of a valuetype instance method
- return values of method calls when all byref arguments have SAFE_BYREF values - the this arg is ignored.
- the address of a static field (LDSFLDA)
- the address of an array element (LDELEMA)
- the address of a field if the receiver is either a SAFE_BYREF value or a reference

Notoriously from the above is the value of local variables. We took a conservative approach of unsafe tainting.
We do this by associating 3 states to a local: unassigned (initial value of zero), assigned and safe (SAFE_BYREF_LOCAL), assigned and unsafe (UNSAFE_BYREF_LOCAL)
When loading a local, we set its value as SAFE_BYREF if the local is in the SAFE_BYREF_LOCAL state.

When storing to a local, we set it to SAFE_BYREF_LOCAL if, only if, it's not marked as UNSAFE_BYREF_LOCAL and the value is SAFE_BYREF.
If we store a non-safe value to a local, we mark it as UNSAFE_BYREF_LOCAL.
If we store a non-safe value to a SAFE_BYREF_LOCAL local, we mark the method as unverifiable.

This algorithm makes sure we don't mix safe and unsafe byref and side with safety in case of control-flow dependent values.

Implement stack overflow handling on Win64. Call _resetstkoflw to restore stack protection before calling handler, and then jump to handler via a cached MonoContext. (#5472)

[TSan] Interlock and unlock MonoJitStats (#5437)

[TSan] Interlock and unlock MonoJitStats

This is the first part of telling TSan what to do with `MonoJitStats`; I dealt with all the `gint32` values and partly touched the `gboolean` value (see `FIXME`). However, `MonoJitStats` also contains `gdouble` which can (1) probably be interlocked and (2) will be updated in a later step, together with the `FIXME`, as soon as an updated version of the atomic interface exists.

I did my best to distinguish between perf. critical parts and parts where `Interlocked* ()` seems to work perfectly fine. As before, if I misjudged anything, I would kindly ask to comment the affected operations, and I will update them accordingly.

More (technical) details can be found in the commit messages.

[System.Xaml] Fix deadlock on exception in XamlBackgroundReader

The ManualResetEvent wouldn't be signaled when an exception happens
in the reader loop so we'd deadlock in Read().

I'm still investigating where the exception comes from but this
should at least help unblocking CI.

https://bugzilla.xamarin.com/show_bug.cgi?id=46683

Merge pull request #5504 from ntherning/wait-for-native-thread-to-die-in-Thread-Join

Wait for the native thread to die in Thread.Join() on Windows

Update CONTRIBUTING.md (#5542)

[F#] Reinstate _DebugFileExt as it's needed for mobile debugging. (#5534)

Also added a mechanism for users to override DebugType

Merge pull request #5428 from kumpera/wasm-support-p2

Mono Wasm support

[threads] Fix "[threads] Fix leaking threads: SGen Worker and Finalizer (#5284)" (#5532)

* Revert "[threads] Fix leaking threads: SGen Worker and Finalizer (#5284)"

The sgen-specific cleanup cannot be run before the sgen-agnostic cleanup

This reverts commit 7db0fb0c886f5157066e26c2e2ae2d39c338cf6b.

* [threads] Make sure we do not leak the finalizer and sgen threadpool threads

F# portable debugging (#5531)

* Switch F# builds over to portable pdb

* Add portable pdb metadata fix from https://github.com/Microsoft/visualfsharp/pull/3553

[Tests] Fix Mono.Data.Tds tests on iOS (#5501)

* [Tests] Fix Mono.Data.Tds tests on iOS

The modified tests failed on iOS following PR:
https://github.com/xamarin/xamarin-macios/pull/2580 that adds support
for Xharness to run the Mono.Data.Tds on Xamarin.iOS. With the changes
the tests run a expected.

* Close Listener when done.

[TSan] Tackle MonoPerfCounters (#5413)

[TSan] Tackle MonoPerfCounters

With `MonoPerfCounters` taking part in many races, I thought it's finally time to attend to it. If I am not mistaken, most (if not all) load / store operations can be interlocked. If I am wrong, I would kindly ask to quickly comment the respective perf. critial operations and I will change them to `Unlocked* ()`.

Furthermore, a few details:

* updated all fields to signed types as `Interlocked* ()` functions exist for these types already
* upgraded a few values to `64-bit` as other `64-bit` values are assigned to them
* fixed a few `FIXME`s in `predef_writable_update ()` that were connected to `Interlocked* ()` functions

Update man page

Shorter

Toggle the turbo button