Merge pull request #2721 from ludovic-henry/fix-mono_ms_ticks

[runtime] Fix potential overflow when using mono_msec_ticks

Merge pull request #2941 from jogibear9988/patch-1

Bugfix DateTime in Sqlite: https://bugzilla.xamarin.com/show_bug.cgi?id=40603

Revert "[verifier] Do method visibility checks for virtual final methods. Enable type visibility for all methods. Fixes #5644."

This reverts commit 24ee5b8db0ab3115f88dcef72432568e3c1b8e83.

Revert "WIP - don't merge"

This reverts commit 359bb511d3cdb2b320fba35d99684152615d5242.

Revert "WIP fix the previous issue."

This reverts commit a26a53369857ed120522c8625b1bebc653f25baf.

[corlib] Reenable IsReadOnly test

[xbuild] Fix ApplicationIcon incremental build dependency

Merge pull request #2942 from jogibear9988/patch-2

bugfix numInfo of Cultureinfo NonSerialized on Windows

Merge pull request #2945 from mono/xi-40574

[linker] Method decorated with System.Runtime.Serialization.*Attribut…

[linker] Method decorated with System.Runtime.Serialization.*Attribute must be marked, Fixes #40574

Some serialization attributes are unlikely to have direct reference,
from IL, but will be needed at runtime to correctly serialize (or
deserialize) objects.

* OnDeserializedAttribute
* OnDeserializingAttribute
* OnSerializedAttribute
* OnSerializingAttribute

This, along with aad627c5e8ddf15397c87fa2d3e18b54f929c927, fixed bug
40574. The later part will have new unit tests in XI.

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

[corlib] Disable core security icalls on mobile

Microsoft relicensed this fork of the Ajax library under the MIT license

Microsoft relicensed this fork of the DLR under the MIT license

Merge pull request #2944 from lambdageek/dev/monoerror-thread_create

[runtime] MonoError-ize mono_thread_create{,_internal}

[runtime] MonoError-ize mono_thread_create{,_internal}

Mark mono_thread_create external only.  Runtime should use
mono_thread_create_checked.

[corlib] FileInfo from referencesource

[corlib] Remove System.Core security types

[corlib] Remove duplicated sources

[System.Core] Add CommonCrypto dependencies

[corlib] FileSystemInfo from reference source

[acceptance-tests] Move roslyn build dependencies to download server

storage.bos.internalx.com is only available via VPN now.

Also bump coreclr to get a recent minor fix.

Merge pull request #2943 from mono/xi-40570

[System.Core] Add back AesManaged to tvOS and watchOS profiles. Fixes #40570

[WindowsBase] Serialization fix of Int32Rect, Point, Rect, Size, Vector, Matrix (#2873)

The problem is that private fields in described types doesn't start from _ prefix, but it should be so according to reference source.
That's way MONO can't deserialize that types correctly if source stream was created by MS .NET binary serializer.

This change is released under the MIT license.

[System.Core] Add back AesManaged to tvOS and watchOS profiles

Switching maccore to use mono-4.5.0-branch introduced this bug where
AesManaged is not available in System.Core for both tvOS and watchOS
profiles (iOS is fine).

This results in unit tests failures on bots building maccore/master.

This fix the problem by importing the "main" monotouch_System.Core.
dll.sources into the other profiles - since they all share the same
feature set (in this case) and make it less likely to forget something
else in the future.

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

[runtime] Allow enums with base type of char in Enum.ToObject (), this is valid in f#. Fixes #40568.

Merge pull request #2940 from xmcclure/disable-jit-gsharedvt

Fix gsharedvt compile on DISABLE_JIT platforms

bugfix numInfo of Cultureinfo NonSerialized on Windows, https://bugzilla.xamarin.com/show_bug.cgi?id=35872

Cultureinfo numInfo is not NonSerialized on DotNet for windows, so it also should not on mono.

http://referencesource.microsoft.com/#mscorlib/system/globalization/cultureinfo.cs,76

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

[I18N/CJK] iso-2022-jp GetChars() had some bogus conversion ranges.

Fix gsharedvt compile on DISABLE_JIT platforms

Merge pull request #2939 from discofire/patch-1

Update OracleConnection.cs

Update OracleConnection.cs

Fix SQL syntax for GetSchemaProcedures function. (Should have been 'SELECT' instead of 'SSELECT')

Merge pull request #2918 from lateralusX/jlorenss/aot-x86-symbol-fix

Windows 32-bit x86 AOT assembler didn't compile due to incorrect symbol mangling.

Merge pull request #2869 from BrzVlad/feature-mod-union-opt

[sgen] Optimize mod union usage

Merge pull request #2935 from kumpera/new-gc-test

[sgen] Add regression test for the interaction between the bridge and handles.

The bridge code was triggering handles to be considered deallocated thus leading
them to be overwritten.

Merge pull request #2932 from ludovic-henry/fix-waithandle-remoting

[corlib] Ifdef out calls to SynchronizationAttribute on monotouch

When WaitHandle was imported from referencesource in f6fa8f0, the code was refactored and basically all WaitHandle.Wait* calls end up in WaitOneNative or WaitMultiple now.

On monotouch those methods threw a NotSupportedException when exitContext == true even before the import, so this behavior got inherited to some other methods that didn't throw after the exception was removed from them in 93e31cb. This broke tests in maccore and other code that passed exitContext=true.

To fix this, we just ifdef out the calls to SynchronizationAttribute on monotouch since they don't make sense there anyway since remoting isn't available. The commit that initially added the exception in 2ce9fc1 only did that to make the behavior consistent when the linker is enabled. By removing the calls we get the same result.

Do the same for Monitor so we're consistent.

commit message from @akoeplinger

Merge pull request #2880 from kumpera/fix_5644

[verifier] Do method visibility checks for virtual final methods. Enable type visibility for all methods. Fixes #5644.

I cannot repro the issue mentioned in the comments of mono_method_can_access_method.

* FIXME:
* with generics calls to explicit interface implementations can be expressed
* directly: the method is private, but we must allow it. This may be opening
* a hole or the generics code should handle this differently.
* Maybe just ensure the interface type is public.

@monojenkins merge

[sgen] Add regression test for the interaction between the bridge and handles.

The bridge code was triggering handles to be considered deallocated thus leading
them to be overwritten.

[docs] Added index.xml entry for CFNetworkHandler. (#2930)

This particular piece of documentation is added manually, because it's not in the regular BCL library, but is provided by Xamarin on the iOS platform. Because it was missing an entry in the index file, it was excluded from the published documentation when doing mdoc assemble.

Merge pull request #2934 from vargaz/fix-36852

[sgen] Avoid returning NULL from null_link_if (), that means an empty…

[corlib] Ifdef out calls to SynchronizationAttribute on monotouch

When WaitHandle was imported from referencesource in f6fa8f0, the code was refactored and basically all WaitHandle.Wait* calls end up in WaitOneNative or WaitMultiple now.

On monotouch those methods threw a NotSupportedException when exitContext == true even before the import, so this behavior got inherited to some other methods that didn't throw after the exception was removed from them in 93e31cb. This broke tests in maccore and other code that passed exitContext=true.

To fix this, we just ifdef out the calls to SynchronizationAttribute on monotouch since they don't make sense there anyway since remoting isn't available. The commit that initially added the exception in 2ce9fc1 only did that to make the behavior consistent when the linker is enabled. By removing the calls we get the same result.

Do the same for Monitor so we're consistent.

[sgen] Avoid returning NULL from null_link_if (), that means an empty slot, not a handle pointing to null. Fixes #36852.

WIP fix the previous issue.

WIP - don't merge

[verifier] Do method visibility checks for virtual final methods. Enable type visibility for all methods. Fixes #5644.

I cannot repro the issue mentioned in the comments of mono_method_can_access_method.

* FIXME:
* with generics calls to explicit interface implementations can be expressed
* directly: the method is private, but we must allow it. This may be opening
* a hole or the generics code should handle this differently.
* Maybe just ensure the interface type is public.

[build] Add missing empty assemblies needed by default csc config

[profile] Fix a regression from last commit.

Merge pull request #2859 from lambdageek/dev/monoerror-object-c

[runtime] Grab bag of MonoError fixes in object.c

[mcs] Fixes crash during conversion error reporting. Fixes #40536

[mcs] null operator receiver type needs to be convertible to null. Fixes #40493

[tools] Fixes compiler tester error messages verification

Merge pull request #2891 from xmcclure/bug-39669

Allow xml configuration sections to reference System.dll (bug#39669)

[profiler] Remove unneeded call to mono_lock_free_queue_node_init.

Remove calls to mono_lock_free_queue_node_init for nodes that just came out of mono_lock_free_queue_dequeue.

That call is superfluous as dequeue will set the returned node 'next' field to INVALID_NEXT, which is the
same thing the mono_lock_free_queue_node_init call did.

Merge pull request #2922 from akoeplinger/fix-tvos

[utils] Fix MONO_SIGNAL_USE_UCONTEXT_T not being defined on tvOS simulator

In the maccore tvossimulator tests we were seeing the following assertion with the Mono 4.5 preview:

```
error: * Assertion: should not be reached at /Users/builder/data/lanes/1381/0d6923b4/source/maccore/external/mono/mono/utils/mono-context.c:194

0   dont link                           0x000000010175702d mono_handle_native_sigsegv + 253
1   libsystem_platform.dylib            0x000000010a0cfeaa _sigtramp + 26
2   ???                                 0x0000000001bfc4db 0x0 + 29344987
3   libsystem_c.dylib                   0x0000000109e56cbc abort + 129
4   dont link                           0x00000001018d1503 _ZL12log_callbackPKcS0_S0_iPv + 67
5   dont link                           0x00000001018c26d0 monoeg_assertion_message + 192
6   dont link                           0x00000001018af6de mono_sigctx_to_monoctx + 30
7   dont link                           0x000000010183f473 sgen_suspend_thread + 323
8   dont link                           0x000000010183f58e sgen_thread_handshake + 126
9   dont link                           0x000000010183fb20 sgen_client_stop_world + 1296
10  dont link                           0x0000000101871283 sgen_stop_world + 67
11  dont link                           0x0000000101870d43 sgen_perform_collection + 99
12  dont link                           0x0000000101872576 sgen_gc_collect + 102
13  dont link                           0x00000001018d1886 _ZL7pump_gcPv + 54
14  libsystem_pthread.dylib             0x000000010a0b7c13 _pthread_body + 131
15  libsystem_pthread.dylib             0x000000010a0b7b90 _pthread_body + 0
16  libsystem_pthread.dylib             0x000000010a0b5375 thread_start + 13
```

This was caused by a4e257a07f511062a8feb3e06e1566fd980110ce, the issue is that the check was changed from UCONTEXT_REG_RAX to MONO_SIGNAL_USE_UCONTEXT_T, but that is only available when HAVE_SIGACTION is defined which it is not in this case.

Talked with Zoltan, fixing this by enabling MONO_SIGNAL_USE_UCONTEXT_T on all apple platforms for now.

/cc @vargaz @xmcclure

@monojenkins merge

Another round of profiler fixes/improvements. PR #2882 (Manually Merged)

https://github.com/mono/mono/pull/2882

[runtime] MonoError-ize mono_ldstr_metadata_sig

[runtime] MonoError-ize mono_string_new_len

Mark it external only.  Runtime should use mono_string_new_len_checked.

[runtime] MonoError-ize mono_wait_handle_new

[runtime] MonoError-ize mono_array_new_cached

[runtime] MonoError-ize mono_array_new

Mark it external only.

Runtime should use mono_array_new_checked.
The icall is ves_icall_array_new.

[runtime] object.c don't raise in external only functions

- Variants of mono_object_new
- mono_object_clone
- mono_array_new_full

All these functions have _checked variants that are used by the runtime.

[runtime] MonoError-ize mono_array_clone

1. Mark mono_array_clone external only.  Runtime should use
  mono_array_clone_checked.
2. Add MonoError* arg to mono_array_clone_in_domain.
3. Separate ves_icall_System_Array_Clone

[runtime] Mark mono_object_new_from_token external only.

Does not appear to be used in the runtime.
Changed it not to raise exceptions.

[runtime] Set pending, don't raise, in object.c icalls

[runtime] MonoError-ize mono_object_xdomain_representation

[runtime] MonoError-ize mono_property_get_value

Mark it external only.  Runtime should use mono_property_get_value_checked.

[runtime] MonoError-ize mono_property_set_value

Mark it external only.  Runtime should use
mono_property_set_value_checked.

Note: mono_property_set_value_checked always catches exceptions from
managed code and threads them out via MonoError.

[runtime] Don't raise exns, set pending exception

[runtime] MonoError-ize mono_runtime_create_jump_trampoline

[attach] Don't raise in mono_attach_load_agent

Merge pull request #2806 from lambdageek/dev/monoerror-marshal_remote

[runtime] MonoError-ize marshal and remoting code

Get rid of calls to `mono_raise_exception` in marshaling and remoting code.

[profiler] Don't link against libmono.

This would result in duplicate runtimes being loaded (as evidenced by
/proc/$pid/maps), which could lead to all sorts of breakage.

[profiler] Load the profiler with MONO_DL_EAGER.

We need to make sure all external references have been resolved so that we
don't invoke the dynamic linker in the mono_sample_hit () callback which is
called in async-signal context.

[utils/dl] Add a MONO_DL_EAGER enum value for clarity.

[profiler] Don't use a real-time signal on Android.

[profiler] Use 'start_unload' events instead of 'end_unload' events to avoid crashes.

'end_unload' events can receive mostly-freed structures.

[profiler] Use a signal to interrupt the sampler thread's sleep if needed.

There is a slight problem when we're using CLOCK_PROCESS_CPUTIME_ID: If we're
shutting down and there's largely no activity in the process other than waiting
for the sampler thread to shut down, it can take upwards of 20 seconds
(depending on a lot of factors) for us to shut down because the sleep
progresses very slowly as a result of the low CPU activity.

We fix this by repeatedly sending the profiler signal to the sampler thread in
order to interrupt the sleep.

We do not need to do this on platforms where we use a regular sleep based on a
monotonic clock. The sleep will return in a reasonable amount of time in those
cases.

[profiler] Add some more counters.

[profiler] Limit the number of allocated sample hit structures.

[profiler] Add counters for log buffers and sample hits.

[profiler] Rewrite the log profiler's handling of sample hits.

The old code had quite a few problems:

1. It would result in stack corruption under heavy load, somehow. This typically
   resulted in an assertion when starting the unwinding process because the
   unwinding flags would be inconsistent.
2. It sometimes wrote complete garbage into the statistical buffers.
3. As a result of using the helper thread to assemble collected samples into log
   buffers, it did not work on platforms where the helper thread is disabled.
4. Performance was poor under heavy load because waking up the helper thread to
   assemble events would always trigger a counters sample + dump.
5. The code was very complicated and hard to understand/maintain.

(Points (1) and (2) can probably be attributed to point (5).)

In the new sampling world order, we use a lock-free allocator and a lock-free
reuse queue to acquire memory for sample hit events in the sample hit callback.
We then fill it with the info we collect during the async stack walk. Finally,
we ship it off to a separate dumper thread (via another lock-free queue) where
it gets turned into a log buffer and then shipped off to the writer thread.

This new approach appears very stable; I've yet to make it crash in any of the
stress tests I typically run. In a heavy workload, the helper thread's CPU
usage was previously around 25-30%. It is now down to basically 0% while the
dumper thread is only around 15%. CPU usage by threads that are collecting
samples is a bit higher than before, but only until the reuse queue converges
on a size that is big enough to satisfy all sample event requests. At that
point, no more allocations from the lock-free allocator happen, and performance
improves.

[utils/lfa] Export the lock-free allocation code for use in the profiler.

[profiler] Add counters for numbers of signals sent/received/accepted.

[counters] Add a profiler category.

[profiler] Make the default sample frequency 100 Hz.

Our previous default (1000 Hz) was quite extreme and resulted in very high
overhead from the profiler for moderate workloads.

Also, fix the profiler to actually treat the 'freq' argument as a frequency
when passing it to the runtime. It was being incorrectly treated as a sleep
interval.

[domain] Report domain unloads to the profiler when finalizing the domain.

We would miss the unload event for the root domain because we reported it just
before freeing the domain, by which time the profiler was detached.

[profiler] Only initialize the sampler thread once.

[System.Configuration] Fail tests on standalone error

Add xml configuration section test (bug#39669)

[System.Configuration] re-enable standalone tests

[utils] Fix MONO_SIGNAL_USE_UCONTEXT_T not being defined on tvOS simulator

In the maccore tvossimulator tests we were seeing the following assertion with the Mono 4.5 preview:

```
error: * Assertion: should not be reached at /Users/builder/data/lanes/1381/0d6923b4/source/maccore/external/mono/mono/utils/mono-context.c:194

0   dont link                           0x000000010175702d mono_handle_native_sigsegv + 253
1   libsystem_platform.dylib            0x000000010a0cfeaa _sigtramp + 26
2   ???                                 0x0000000001bfc4db 0x0 + 29344987
3   libsystem_c.dylib                   0x0000000109e56cbc abort + 129
4   dont link                           0x00000001018d1503 _ZL12log_callbackPKcS0_S0_iPv + 67
5   dont link                           0x00000001018c26d0 monoeg_assertion_message + 192
6   dont link                           0x00000001018af6de mono_sigctx_to_monoctx + 30
7   dont link                           0x000000010183f473 sgen_suspend_thread + 323
8   dont link                           0x000000010183f58e sgen_thread_handshake + 126
9   dont link                           0x000000010183fb20 sgen_client_stop_world + 1296
10  dont link                           0x0000000101871283 sgen_stop_world + 67
11  dont link                           0x0000000101870d43 sgen_perform_collection + 99
12  dont link                           0x0000000101872576 sgen_gc_collect + 102
13  dont link                           0x00000001018d1886 _ZL7pump_gcPv + 54
14  libsystem_pthread.dylib             0x000000010a0b7c13 _pthread_body + 131
15  libsystem_pthread.dylib             0x000000010a0b7b90 _pthread_body + 0
16  libsystem_pthread.dylib             0x000000010a0b5375 thread_start + 13
```

This was caused by a4e257a07f511062a8feb3e06e1566fd980110ce, the issue is that the check was changed from UCONTEXT_REG_RAX to MONO_SIGNAL_USE_UCONTEXT_T, but that is only available when HAVE_SIGACTION is defined which it is not in this case.

Discussed with Zoltan, fixing this by enabling MONO_SIGNAL_USE_UCONTEXT_T on all apple platforms for now.

[runtime] Remove use of mono_raise_exception in mono_object_isinst_mbyref_checked

[remoting] Remove calls to mono_raise_exception

1. MonoError-ize mono_remoting_wrapper icall.
   This is a bit this method is allowed to use
   mono_error_raise_exception: it is called from a
   MONO_WRAPPER_REMOTING_INVOKE method which is considered a "protected
   wrapper" in which the usual pending exception interruption check is a no-op.
2. Use mono_set_pending_exception in mono_marshal_set_domain_by_id icall

fixup f5dc934

[mcs] Don't do empty array interpolation on user code, weird code expects empty array not to be equal

Windows 32-bit x86 AOT assembler didn't link correctly.

When running basic make check in mono/mini there are some hidden errors in the check-seq-points test. Current test compares output between JIT and AOT compile assemblies but doesn't pay attention to the result of the as and ld calls building the AOT:ed modules. It turns out that the linkage of the AOT compiled module on win32 x86 actually fails due to naming of symbols included in .def or .globl assembler expressions. The fix makes sure that local function symbols or global symbol definitions follows the cdecl win32 x86 convention and are prefixed with _. The fix tries to resolve this using two different strategies. Since there are many code paths in the AOT compiler emitting local/global symbols + referencing the emitted symbols, it doesn't look like there is one place to fix this (unless rename the symbol altogether and that could cause regressions elsewhere).

First, local function symbols are emitted using .def expression when used as debug symbols. By prefixing debug symbols with _ will resolve most of the local function symbols. By mangling the debug symbols we can fix both emitted symbols and references to these symbols in two location (get_debug_sym, get_plt_entry_debug_sym).

Second, in order to make sure all other symbols (local/global) ending up in .def or .globl expressions are correctly mangled, the functions to emit local/global symbols in aot-compiler.c have been extended to check mangling on passed in symbols before emitting. If passed in symbol doesn't follow the name mangling rule, the symbols will be mangled and the mangled symbol will be emitted together with a label to the mangled symbol. This is done to make sure we have a correct label for the emitted symbol that can be used by the linker. Since the rest of the code is unaware of the mangled name, it will continue reference the unmangled name and since there is already a label to the unmangled symbol, the mangling will be transparent for the rest of the code.

NOTE, the fix only applies to windows X86 build, other configurations are not affected by this issue.

This PR also includes a fix detected on windows when debugging and fixing above issue. The AOT compiler tries to rename linked module to the final target name, for example from basic.exe.dll.tmp to basic.exe.dll. If the file already exist, the rename will fail on windows causing a silent failure in the AOT compiler and this will "leak" the tmp file + ending up with the old basic.exe.dll. The fix is to check result of the rename function call and if it fails with "file already exist error", unlink target and redo rename operation. The rename can still fail due to other reasons ending up in the same problem, but to make a good fix, the error handling of the method needs to be revisited in order to properly clean up tmp files and allocations in error cases. This will be handled in a different PR.

[symbolicate] Switch to Cecil backend

[monosymbolicate] Small cleanups

Support custom Xamarin Android HttpClient handler

Make it possible to select a default System.Net.HttpClient handler
on Android. Selection of the handler is handled on the Xamarin Android
side.

Merge pull request #2863 from alexrp/windows-critsect-debug-info

[utils/mutex] Initialize Win32 critical sections without debug info.

[offsets-tool] Fix path to Options.cs