[System] Flush few colliding changes

[runtime] Use new mono_error_set_for_class_failure where applicable.

We were seeing an issue where attempts to create the MonoClass for an
exception in a no-exec context was causing failure. No-exec will forbid
the constructor call. Our solution was to realize that there was no
need to allocate an exception, as MonoError could already encode the
errors.

[runtime] Make helper to set MonoError directly from MonoClass error

Correct typo

Correct for widechar on Windows

[mcs] Fixes NRE during error reporting

[System] Remove duplicate file entry

Several corrections thanks to Johan Lorensson

[WinForms] Fix build broken by 5d54803af7af4c78cfeac020e0e2046b1282af91

Correcty initialize image ref_count. Ensures image is correctly unloaded during appdomain unload. (#3084)

Merge pull request #3102 from alexrp/master

[System] Add back IWebProxyScript to the mobile profile.

[System] Add back IWebProxyScript to the mobile profile.

SWF - Fixed exiting modal runloop. (#2980)

Fixes a bug in exiting modal runloop that caused not really exiting it
(not calling XplatUI.SetModal(..., false).

It caused issues with menu, for example, if you first ran a modal
dialog (a wizard), and then you started the application.

Merge pull request #3099 from marek-safar/rs-Semaphore

[System] Semaphore from referencesource

[mobile_static] Removed use of StringAssert nunit helper.

[sgen] Use raw mutex for pin_queue_mutex as it's only used during a collection

[coop] Reuse local info variable for polling

This would lead to a crash when unregistering the thread from the currnt MonoThreadInfo* destructor, as `mono_thread_info_current_unchecked` would return NULL. This would trigger an infinite loop in `mono_threads_enter_gc_safe_region_unbalanced_with_info`.

[marshal] Fix unused variable warning

[threads] Make mono_thread_detach_if_exiting return if it detached

[coop] Use mono_thread_info_is_current in checked build

[coop] Remove unecessary assertion

[coop] Switch to GC unsafe state in SIGILL signal handler as it may throw an exception

[runtine] We should always ignore SIGPIPE signal

[coop] Ensure GC unsafe state when throwing exception

[coop] Switch to GC safe around pthread_join

[coop] Do not pass current thread to mono_threads_enter_gc_unsafe_region_cookie

[coop] Fix state transition when unregistering the thread

unregister_thread is the destructor for the current MonoThreadInfo* TLS key, meaning that when in this function, calling mono_thread_info_current_unchecked will always return NULL.

[coop] Make GC safe/unsafe unbalanced transitions public

This is needed by Xamarin.iOS for unbalanced transitions, for example aroung a ObjC @throw.

[coop] Do not include mono-threads-coop.h and mono-threads-api.h in mono-threads.h

This leads to circular dependency between them, while mono-threads.h does not depends on the other 2.

[coop] Do not allow transition on not-attached, not-current and not-live thread

[coop] Remove unecessary GC unsafe transition

[marshal] Fix setting of last error for P/Invoke

On Unix, errno value might change between the native call and the call to mono_marshal_set_last_error, if we exit the gc safe region. We need to ensure that it's done right after the native call.

[checked-build] Fix warning

[coop] Remove DoneBlockingAborted state transition

This state transition would only be possible in case something went wrong. It's better to fix where this issue comes from.

Merge pull request #2881 from alexrp/gc-sample-managed-alloc

[gc] Register a critical region when executing managed allocators.

Previously, if we stopped a thread and it had a stack looking like this:

    ...
    profiler_signal_handler
    <signal handler called>
    managed_allocator
    ...

We would fail to identify the fact that we've just interrupted a thread that's
in a managed allocator (uninterruptible code) because we only look at the very
latest instruction pointer of the thread, which will be pointing into
profiler_signal_handler or some other function called by it. So we would
happily continue along with the STW process and proceed to doing the actual GC,
where we would see a broken heap.

We could solve this by unwinding the stack and checking all frames, but that's
complicated and error-prone. Instead, register a critical region while the
managed allocator runs. This way, if we don't identify it by instruction pointer, we
will identify it by the fact that the thread is in a critical region.

Merge pull request #3066 from alexanderkyte/pedump_sgen

[runtime] Replace pedump boehm dependency with sgen dependency

[runtime] Mark mono_exception_from_token_two_strings external only

Runtime should use mono_exception_from_token_two_strings_checked

[runtime] Mark mono_exception_from_name_two_strings external only.

Runtime should use mono_exception_from_name_two_strings_checked

[System] Semaphore from referencesource

Correct use of localtime() in Win32

Use localtime for Win32 and localtime_r for others

Correct syntax error and G_LOG_xxx identifier

Correct use of Windows APIs

Use correct APIs for Windows; Remove sys/time.h

Correct conditional compilation & move logger source files to correct place

[runtime] Mark mono_runtime_run_main external only.

Runtime should use mono_runtime_run_main_checked or mono_runtime_try_run_main

[runtime] Mark mono_runtime_exec_main external only.

Runtime should use mono_runtime_exec_main_checked or mono_runtime_try_exec_main

Merge pull request #3087 from lambdageek/dev/monoerror-mono_object_to_string

[runtime] Mark mono_object_to_string external only.

[System] Internal connectionpool from referencesource

Merge pull request #3096 from alexrp/master

[bcl] Avoid ObjectDisposedException in EndPointListener.

[corlib] Fixes mobile tests

Merge pull request #3097 from rolfbjarne/mono-api-info-compare-generic-method-parameters

[mono-api-info] Take number of generic parameters into account when comparing methods.

[mono-api-info] Take number of generic parameters into account when comparing methods.

[arm] Return structures with sizes up to 16 bytes in int registers on watchos. Fixes #41393.

[bcl] Avoid ObjectDisposedException in EndPointListener.

This fixes a regression introduced in 123aaa5db07fe464d12ea178ecc3f27990cc1a72.
We would sometimes see an ObjectDisposedException when calling AcceptAsync ()
because that patch removed the try-catch around it.

Merge pull request #3094 from mbrophy1/master

Add missing type forwarder for System.Diagnostics.Tracing.EventSource…

Merge pull request #3095 from alexanderkyte/typespec_cache_fix

[runtime] Don't free null cache hash table in aot compiler

[runtime] Don't free null cache hash table in aot compiler

Halve the stack depth for both the new single step tests

[genproj] More updates to the project files, getting closer, down to 5 errors

Add missing type forwarder for System.Diagnostics.Tracing.EventSourceSettings.  ASP.net Core 1.0 RC2 apps will not run against mono without this.

[runtime] Comment external only functions that call mono_error_raise_exception

[runtime] Mark mono_object_to_string external only.

Runtime should use mono_object_to_string_checked and mono_object_try_to_string.

Xamarin.Android test suite updates

Xamarin.Android internal test suite takes advantage of the BCL tests
in Mono, so far their inclusion was a manual process and this commit
fixes it. A set of source inclusion and exclusion lists is added
and a handful of code fixes to make them compile on Xamarin.Android

[corlib] Disable even more cas in mobile

[runtime] Replace pedump boehm dependency with sgen dependency

Merge pull request #3081 from lambdageek/coop-no-prof

[coop] Disable profiler tests if coop is enabled

Merge pull request #3086 from esdrubal/master

[System] Fixes socket async exception.

SendAsyncFile uses StartSocketServer to start a server and at the same
time begins to accept a client socket. The issue is that when
the accept callback is called SendAsyncFile already closed the socket.

Fixed race condition by moving StartSocketServer and ReceiveCallback
logic into SendAsyncFile, and by using a new MRE to ensure that the
client receives all the data before the server is closed.

Fixes [#41264](https://bugzilla.xamarin.com/show_bug.cgi?id=41264)

[corlib] Disable more CAS code

[coop] Disable profiler tests if coop is enabled

[System] Fixes socket async exception.

SendAsyncFile uses StartSocketServer to start a server and at the same
time begins to accept a client socket. The issue is that when
the accept callback is called SendAsyncFile already closed the socket.

Fixed race condition by moving StartSocketServer and ReceiveCallback
logic into SendAsyncFile, and by using a new MRE to ensure that the
client receives all the data before the server is closed.

Fixes #41264

[mcs] Use only mcs specific assembly references resolver. Fixes #29189

Fix for non GCC win x64 calling convention when passing empty structs over pinvoke.

Standard C and C++ doesn't allow empty structs, empty structs will always have a
size of 1 byte. GCC have an extension to allow empty structs,
https://gcc.gnu.org/onlinedocs/gcc/Empty-Structures.html. This cause a
little dilemma since runtime build using none GCC compiler will not be
compatible with GCC build C libraries and the other way around. On platforms
where empty structs has size of 1 byte it must be represented in call and cannot
be dropped.

Libraries build using for example MSVC failed pinvoke call when empty
structs where used in pinvoke2.cs tests. The problem was that current
implementation dropped value types of size 0, eliminating them from the
call. Since MSVC implements C/C++ standard regarding empty structs (no extension used),
the function expected the parameter to be present, even if was not used.
This became a problem if the empty struct ended up in one of the 4 first
parameters (backed by registers) since if excluded, wrong parameter gets
into wrong registers (the same will apply to stack slots as well). For example,
a C signature like this, (int a, EmptyStruct es, int b) will get lowered to the
following on MSVC win x64, a -> rcx, es -> rdx and b -> r8, but since caller
eliminated es from the call, the register assignment from the caller was
a -> rcx and b -> rdx causing a violation of the calling convention and
error in callee.

The fix is to make sure that empty structs are still represented on none GCC
compilers on windows x64 (MSVC), since they must be represented in the call
to pinvoked methods. Fix will also use a const value of 0 to represent the value
passed as the struct instead of loading a value from stack into register/stack slot,
this is inline with the value the .NET runtime passes to pinvoked method. The reason
why we use a 0 instead of loading from stack is because a struct of size 0 is not explicitly
represented on stack and will have garbage data if loaded. Since it’s an empty struct value
type there is no need to load anything, just represent it as 0 in the register/stack slot passed
to caller.

There is also a case when returning an empty struct from a pinvoked method. Result will be returned
as 0 in RAX by MSVC compiled libraries (or whatever value stored in the 1 byte representation).
Since we have similar issues as above with empty structs of size 0 not explicitly represented on the
stack, the store will be eliminated and not written back to stack by caller since an empty struct doesn’t
represent any unique data.

Calling convention for managed->managed code is kept intact since it is working as expected
handling the case with empty structs as input and return values.

With fix all pinvoke2.cs tests now pass running on Windows x64 JIT.

[mcs] Adjust correctly newline counter inside pragma warning

[System] Fixes bootstrap build with old mcs

[arm] Pass structures larger than 16 bytes by ref on watchos. Fixes #41393.

[sgen] Remove a pointless memory barrier from the middle of the managed allocator.

This appears to serve no purpose as tlab_next is a thread-local variable. It's
only ever accessed by other threads in order to write to it, not read it. We
also don't do this memory barrier in the native allocation functions.

[arm] Don't emit memory barriers for relaxed atomic loads/stores.

[sgen] Cache the SgenThreadInfo pointer in a local when emitting managed allocators.

[gc] Register a critical region when executing managed allocators.

Previously, if we stopped a thread and it had a stack looking like this:

    ...
    profiler_signal_handler
    <signal handler called>
    managed_allocator
    ...

We would fail to identify the fact that we've just interrupted a thread that's
in a managed allocator (uninterruptible code) because we only look at the very
latest instruction pointer of the thread, which will be pointing into
profiler_signal_handler or some other function called by it. So we would
happily continue along with the STW process and proceed to doing the actual GC,
where we would see a broken heap.

We could solve this by unwinding the stack and checking all frames, but that's
complicated and error-prone. Instead, register a critical region while the
managed allocator. This way, if we don't identify it by instruction pointer, we
will identify it by the fact that the thread is in a critical region.

[genproj] Another library works, System.Json.Microsoft

Merge pull request #3080 from BrzVlad/feature-enable-conc-master

[sgen] Enable concurrent major by default on desktop platforms

[genproj] support for using prebuilt resources

Fixes for peer feedback on recursive step patch

Made breakpoint uniqueness test switch to a hash after 8th item added,
consolidated the code that handles the uniqueness test and makes the
breakpoint in one function, fixed style issues.

[genproj] Getting closer to a full build
* Add TODO list
* Use -useSourcePath when building resources, so we do not need to add the explicit extra path
* More updates, now battling resource generation across the board
* Use newlines in the Unix commands to avoid generating things like cs-parser.cs^M

Merge pull request #2871 from BrzVlad/feature-conc-sweep-nrs

[sgen] Run sweep concurrently with nursery collections

Merge pull request #3019 from schani/fix-major-pinning

Fix major pinning, and cheap pinning stats by default

[mcs] Add more of undocumented C#6 improved overload resolution

[genproj] Update build files

[mconfig] Remove dependency on build time settings

Merge pull request #2377 from joelmartinez/docs-multiassembly-extension-fix

[mdoc] Extension method crash fix, removes -multiassembly

Make log header message consistent

[mdoc] Extension method crash fix, removes -multiassembly
The tests added during the initial development of the -multiassembly argument failed to test the presence of extension methods;
the result was a crash that occurred when there were extension methods present in multiple assemblies.

This patch addresses the issue by putting a guard clause around the code that adds the extension method to the index.
Tests have been modified accordingly to verify this bug and include extension methods

Additionally, the -multiassembly parameter was removed entirely. This behavior is now triggered by the presence of -apistyle,
which is where support for "multiple assemblies" was meant to work anyways. To review, this is to support cross-platform
development, where you have multiple -- *different* -- assemblies for each platform. These assemblies will share a certain
cross-section of APIs that will be *exactly* the same in each assembly (as opposed to multiple versions of literally the same assembly).
As a result, every member will now contain an individual `AssemblyInfo` tag that also contains the name of the assembly.

[sgen] Enable concurrent major by default on desktop platforms

Merge pull request #3078 from akoeplinger/fix-test-exclude-filename

[build] Make exclusion filename consistent between library and test

Merge pull request #3067 from lambdageek/dev/monoerror-stringy

[runtime] Deal with MonoErrors from string_to_utf8_checked changes

Merge pull request #3059 from lateralusX/jlorenss/win-x64-dyncall-gsharedvt-support

[aot] Added support for GSHAREDVT and DYNCALL on Windows x64 for full AOT builds.

Merge pull request #3076 from akoeplinger/fix-ziptime-offbyone

[WindowsBase] Fix off-by-one error in ZipTime

[WindowsBase] Fix off-by-one error in ZipTime

The date/time struct in zip.h defines the month value as

    uInt tm_mon;            /* months since January - [0,11] */

.NET's DateTime object in turn stores months from 1-12. We didn't
take this into account when passing the values from managed->native
so the month ended up being off by one.

We didn't use this codepath before https://github.com/mono/mono/pull/3036
that's why it didn't show up until now.

[build] Make exclusion filename consistent between library and test

The test assembly used *.dll.excludes before while the library uses *.dll.exclude.sources.
Make this consistent to reduce confusion.

Also remove corlib_cmp.dll.excludes which is from a profile that no longer exists.