Merge pull request #1618 from alexanderkyte/remoting-fix

[Runtime] Fixed remoting bug where too specific a type reflected.

[jit] Use mini_get_underlying_type () in a few places in the amd64 backend.

[jit] Finish support for valuetype based sharing in JIT mode, not enabled yet.

[jit] Add a new MONO_RGCTX_INFO_ELEMENT_KLASS info type and use it instead of MONO_RGCTX_INFO_KLASS on klass->element_class, the latter doesn't work with valuetype sharing.

[metadata] Handle denormalized value type encoding of builtins.

All primitive types have a short encoding format that avoid using
a typeref token.

It's possible to encode them in another, longer, form with ELEMENT_TYPE_VALUETYPE + a typeref token.

Up to now, this was never seen in the wild so we never supported it.

This patch allows long form encoding of primitives.

[threading] Fix a race condition between managed suspend/abort and GC STW.

STW and managed suspend share a lock to ensure there is only one active suspend initiator.

This originally caused a problem in the managed suspend path as it could be async suspended while it was
in the middle of the suspend protocol (check if top of stack is managed, install abort handlers, etc).

This was worked around by putting that inside a suspend critical section. The resulting code was horrible
as suspend boundaries became unstructured (yeah, pretty stupid idea on my end). Not only that but it had
a race condition.

If a thread doing managed suspend raced with a STW and lost, it would block on the global suspend lock to
finish. That thread would be blocked inside a critical section - the single thing you must not do inside one.

This could be reproduced by stressing mono/tests/sgen-new-threads-dont-join-stw.

The solution is to execute the managed suspend sequence in the same fashion as of a STW. IOW, take locks,
suspend, do stuff, maybe resume and drop locks.

The critical part is the "do stuff" one, which is different for abort and suspend, but everything else
is the same. So we wrap that into a callback and put the common parts in mono-threads. This gives
us structured locking and suspend boundaries.

This won't cause a GC to take longer to init as the critical section would block the  STW from progressing
anyways.

[runtime] Fix warnings.

[jit] Throw the proper exception on integer overflow from div/rem if MONO_ARCH_NEED_DIV_CHECK is defined.

[jit] Add another test for gsharedvt+vtype byref argument passing.

Add documentation information about IRI parsing

[corlib] Added exception to fail tests on non aborted system calls.
While running tests if a socket is closed while blocking system calls are pending an exception is thrown.
A socket should not be closed when a blocking system call is pending.
The purpose of the exception is to inform us when AbortRegisteredThreads is not working.

[runtime] Check that thread_suspend returns KERN_SUCCESS.
mono_threads_core_abort_syscall no longer calls thread_abort_safely in case thread_suspend returns errors.

[runtime] Updated Socket_to_SOCKET to use SafeSocketHandle.
The type of field of Socket.socket was changed from IntPtr to SafeSocketHandle.

[aot] Better report errors when loading methods.

[mono-error] When fetching the error message for native usage, include assembly, type and member fields after the message.

[eglib] Fixed file being created without read/write permission on Windows.

This bug manifested itself as files being written to disk with 0 bytes.

Fixes the AOT compiler on Windows not working properly.

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

[mcs] Don't crash after reporting missing type in type arguments of generic method run in probing mode. Fixes #27737

[corlib] TimeZoneInfo.TryGetTransitionOffset overflow checks.

[system] Fixes mobile build

[corlib] Fixed DateTime overflow check in TimeZoneInfo.

Revert "[runtime] Fix mono_class_instance_size () to work with dynamically created types."

This reverts commit 501f0aa6459d1bdbc65680b30c89ba4c7b79fe55.

Revert this as it breaks some corlib tests.

[runtime] Fix mono_class_instance_size () to work with dynamically created types.

[runtime] Remove unused `ves_icall_type_is_subtype_of()`.

[jit] Enable the gsharedvt testcase which now works.

Merge pull request #1621 from schani/fix-warnings

[runtime] Fix warnings.

[runtime] Fix warnings.

[io-layer] When checking if a file is a program check both read and execute permissions. Fixes #27565

The original behavior of only checking for read permission broke sudo on OSX which only have the execute permission set.

[threading] Split unwind state into sync and async.

Having a single unwind state means writes to it must be synchronized between sync and async suspend. We can't
have the state be broken as it could lead to bad unwinding or GC marking.

The original solution was to have an additional state in the self suspend path that signals it's writing to the
thread state and thus any async suspend must give up and let it finish. This ended up been overly complicated
as this requires two additional states instead.

By having a pair of unwind states both can write concurrently without the fear of clashing. This makes fetching the state
a little bit trickier but worth the trouble.

The simplified design has a much smaller state space, which is easier to reason about.

[threading] Change request async suspend to return 3 states instead of one to account for async racing to the middle of a self suspend.

When begin async suspend lands in STATE_SUSPEND_IN_PROGRESS, the initiator don't need to perform an async suspend, it just needs to wait.

If a self suspend is promoted to an async suspend, it must be added to the pending ops set. This ensure that it will be waited otherwise
the suspend initiator might witness an unfinished self suspend and assert when fetching the thread state.

The alternative would be to change finish async suspend to account for the possibility of witnessing STATE_SUSPEND_PROMOTED_TO_ASYNC.

Solving this way requires less async suspends and doesn't increase the valid state space.

[threading] Rework suspend code to be based on a state machine and eliminate known races in the process.

The new suspend machinery is based around a single word state machine that is manipulated using CAS.

This solves the first set of problems with the current approach, the lack of atomicity and the impossibility of
doing race free manipulation of protected state. This is specially acute when doing a self suspend.
Suspend data must be atomically protected while we prepare to self suspend so a resume request won't race with the current
thread putting itself to sleep. This is a classical problem that calls for a mutex/conditional variable pair. Except that all
locks in the suspend path must be suspend safe. Wait, WHAT?

A Suspend Safe Lock is a primitive that is obstruction free in the face of the kernel suspending a thread either performing a
lock operation or waiting on a lock to become available. This, unfortunately, is not possible with pthread_mutex on OSX. The
only safe primitive are kernel semaphores, for which doesn't exist conditional variables for.

So back to locking and self-suspend. We need a lock because the existing thread state is not atomic but we can't use a
mutex/condvar pair so we're left with racy code. Yay! The fix is using CAS over a single variable.

Another change was the hardening of the suspend/resume code on posix targets. First we replace a semaphore wait with
sigsuspend for async suspend. This is needed since sem_wait is not async-signal safe (yet sem_post is). Second, we now
respect interruption requests by having a pair of suspend signals, one with SA_RESTART and one without.

Onto the design of the suspension system, a few concepts that are useful looking around.

* Self suspend: This is when the thread decides to suspend itself.

* Async suspend: This is when a thread decides to suspend another thread.

* Suspend Initiator: This the name of a thread that decided to suspend one or more other threads. This is important
since all suspending threads will notify it when they are suspended. There can be only one initiator in the system
at a given time.

* Suspension count: Number of resume calls before a thread is back to running state.

There are 7 states that can happen while a thread is runnable:

* Running: just running...

* (Async|Self) Suspended: Suspended, the difference comes into play when resuming.

* (Async|Self) Suspend Requested: Suspend requested, but not completed. See more below for the discussion on why the request state is needed.

* Suspend In Progress: Self suspend started saving its state thus async suspend should not modify it.
* Suspend Promoted to Async: Async tried to suspend a thread in the middle of a self suspend, it wants to be notified.

Now to the suspension protocol and how it happens on a high level view.

Suspension starts with a suspend request, which bumps the suspend count by one. This suspend request can be fulfilled either
by an async or self suspend action. This is confusing as there's only one initiator but any number of threads can be self suspending.

Async suspend then performs a platform specific action such as posix signals that forces a transition on the target. In the case
of self suspend, it depends on the thread polling its state and trigger the transition.

This works fine except that the suspend state is one huge struct with tons of fields. To control concurrent access to it we use a
single initiator in the case of async suspend and we put the thread in a transitional "saving my state" in the case of self suspend.

In the case of async suspend, the initiator must wait for all 1+ threads to notify back that they have suspended. Only after that
it's possible to know if the async suspend request actually worked or not (we might have hit a dying thread).

Together with this, there's an optional implementation of STW in sgen that can use this new machinery. To enable it set the
MONO_ENABLE_UNIFIED_SUSPEND env var for now while it gets more testing.

[system] Fixes InvalidCastException in OpenReadAsyncCallback

[runtime] Replaced unsafe thread_abort calls.

[corlib] TypeDelegator from reference sources

[msvc] Change target MSVC release from v120 to v120_xp

They're basically the same thing, but v120 has DX10+ capabilities and v120_xp
is DX9 only. Since we're not building against DirectX, the difference is
purely academic - but changing the value to v120_xp means MSVC binaries run
on XP+, not Vista+

[runtime] Make read_enum_value endian aware

[Microsoft.Build.Engine] Fix invocation flags not to contain both CreateInstance and Invoke

[System.ComponentModel.DataAnnotations] Update test as validation attributes needs to be public

[msvc] Refresh .def files

Bump winconfig.h to 4.1.0

Use MSVC2013 for *all* mono.sln dependants

Add _WIN32_WINNT to Release definition, not just Debug

[corlib] Fixes build, add missing file

[corlib] Type from reference sources

[mcs] Check operator parameter types using common declaration type

[runtime] Make the size of the pseudo classes created by make_generic_param_class () the same as a valuetype with one field of the appropriate type.

[jit] Reorganize the gshared code a bit to make it easier to add support for valuetype sharing.

[jit] Handle type variables in mini_emit_stobj ().

[jit] Move some gshared related code to mini-generic-sharing.c.

[jit] Rename 'constrained_call' to 'constrained_class' to better reflect its type.

Fix some bugs in 92ca06aa7dc4073bdc52f45842a1fbc2fdfce7bf. Fixes #26989.

[jit] Fix the handling of byref locals in mono_allocate_stack_slots2 ().

[tests] Test case for #27147.

[sgen] Fix a bug in 64 bit LOS cardtable scanning.  Fixes #27147.

Fix the build broken in 40ba1978bc274c820141fab18177e2bb17efd3b4

Merge pull request #977 from jasonleenaylor/bug-18558

Fix for Bug 18558

Merge pull request #1579 from esdrubal/aotsp

Sequence points and symbolicate improvements

Merge pull request #1612 from esdrubal/socketsh

Changed Socket to used SafeHandle instead of IntPtr.

Fix the build.

Fix a crash introduced by 15c813d8fda7998688d17b2996543f2e1476ec88.

[runtime] Add support for generic params with gshared constraints to mono_type_get_basic_type_from_generic ().

[runtime] Make the image->gsharedvt_types into an array.

[runtime] Handle gparams constrained to vtypes correctly in mono_class_array_element_size ().

[system] Remove closed connection groups from service point manager. Fixes #25254

Merge pull request #1620 from alexanderkyte/bug-27755

Fixed early termination of string parsing on non-space whitespace.

[mono-symbolicate] make check now tests aot with and w/o .msym.

[runtime] Added --aot option gen-seq-points-file.
.msym file is now only generated if option gen-seq-points-file is used.

[mono-symbolicate] Updated README to the same content as man page.

[mono-symbolicate] Added tool man page and script.

[mono-symbolicate] Replaced mcs --debug flag usage with -debug.

[mono-symbolicate] Fixed wrong Directory.Exists check.

[runtime] Updated comment with wrong corlib path.

[runtime] emit_exception_debug_info no longer adds seq point flag on release.

[runtime] ves_icall_get_trace can now return a -1 IL offset.
This change was made so StackFrame dumps now show a native offset when the IL offset is unknown.
The native offset can be used by mono-symbolicate tool to retrieve an IL offset from a .msym file.

[mono-symbolicate] make check now also runs test with AOT.

[mono-symbolicate] Tool is now using .msym files with AOT.
With AOT sequence points are stored in a .msym file.
As the sequence point data is not avaible at run time, AOT stack traces display a native offset.
mono-symbolicate tool is now able to retrieve an IL offset from a method name, native offset, and the data stored on the .msym file.
The IL offset can then be use to retrieve a filename and line from a .mdb file.

[corlib] Added icall System.Diagnostic.StackFrame.GetILOffsetFromFile.
This method is required by the tool mono-symbolicate.

Disable SecurityFrame, the runtime code in declsec.c creates cross-domain references which cause GC crashes when running the System.Web testsuite.

[runtime] Moved some seq point code from mono/mini to mono/metadata.
Created files metadata/seq-points-data.c and .h.
Sequence points data structures were moved to metadata so we can perform icalls on them.

[runtime] AOT now uses file to store release mode sequence points.
Sequence point data is now stored in a .msym file.
This change removes the sequence points memory overhead from assemblies to be deployed on devices.

[runtime] Added SeqPointData used to write/load sequence points.

[runtime] Improved seq_point_info_write/read has_debug_data encode.

[mono-symbolicate] Changed files to use new tool name.

[symbolicate] Renamed symbolicate to mono-symbolicate.
Renamed the tool to a name that will not conflict with other installed tools.

[runtime] Fixed Process.GetProcesses ().
Process.GetProcesses () was not returning any processes.

[Remoting] Fixed remoting bug where too specific a type reflected.

[Remoting] Moved helper methods from CAD call class to parent class to enable remoting fix.

Fixed early termination of string parsing on non-space whitespace.

Merge pull request #1622 from akoeplinger/fix-datetime-test

[corlib] Fix timezone dependent DateTimeOffset test

[runtime] Fixed Windows mono_threads_core_get_stack_bounds to work with cross-compiled targets.

[corlib] Fix timezone dependent DateTimeOffset test

Instead of trying to recreate the date with the current timezone, we should make the date assume UTC and compare against that.

[DataContractJsonSerializer] Allow abstract base classes in lists. Fixes #26998

Abstract classes can still have subclasses with KnownType attributes, which are allowed in deserialization.

This used to work as the '__type' hint  was always honored no matter the type, and broke with https://github.com/mono/mono/commit/71e152accc727089faffa6b4fd6bf58cb62636cf which removed that behavior.

Merge pull request #1619 from akoeplinger/flaky-dataflow-test

[Dataflow] Disable flaky FaultExecutingConsume () test

[Dataflow] Disable flaky FaultExecutingConsume () test

It fails randomly on Jenkins and my own CI. To reproduce, just wrap the body of the test in while(true) and run for a few minutes.
I tested on MS.NET as well and it fails the same way there, so it's not Mono's implementation of Dataflow.

Filed https://bugzilla.xamarin.com/show_bug.cgi?id=27757 for tracking.

[jit] Rename MonoGenericParam->serial to 'gshared_constraint', use it to calculate object sizes/layouts correctly if a generic param matches a non-reference type during gsharing.

[UnixRegistry] Fix leak (#25559), remove races.

There was a memory leak caused by not having a lookup mechanism for
the RegistryKey.  In addition, the entire code to dispose code was
never used (due to the leak), and it was wrong.

In addition, added locking to the "values" field, which currently was
racy.

No test cases, the repro is to run the above code for about 5 minutes.

Enable x86 cross compilation on Windows.

Do not try to use the native GCC linker when targeting Android from Windows.

Fixed Windows system commands calls with non-ASCII paths.

This is a bit of an hack but it works for now... ideally we should be processing the Unicode command line flags passed by the CRT at startup instead of trying to convert the MBCS string to a wide string.

Remove the EXPORT ciphers and related code path

    That was still useful in 2003/2004 but the technical and legal landscape
    changed a lot since then. Removing the old, limited key size, cipher
    suites also allow removed additional parts of the code that deals with
    them.

Remove the client-side SSLv2 fallback.

    There's almost no SSLv3 web site left so a v2 fallback is only extra
    code we do not need to carry forward.