[offsets-tool] Remove dependencies on android directory layout by adding a --targetdir=dir argument argument which points to the mono build directory corresponding to the target abi. Only allow one --abi= argument on android. (#4487)

[System] Collections from CoreFX

Bump corefx

[ci] Check if X server is available before running WinForms tests (#4477)

This should hopefully "fix" the mass fails in the WinForms
tests we sometimes see in CI.

We're using the simplest WinForms code that invokes the XplatUI
and causes the X connection to be established, if this fails
then something is seriously wrong and we skip the WinForms tests.

[arm] Implement aot support for handler block trampolines.

[arm64] Implement aot support for handler block trampolines.

Merge pull request #4481 from migueldeicaza/master

[mkbundle] Fixes the embedding of dependency assemblies + test

[runtime] Fix pedump.

RFI - Support building System.Drawing for NETCOREAPP2.0 (#4483)

[mono/tests] Don't use -lib:<dir> use -r:<dir>/asm.dll for framework assemblies

Apparently Roslyn looks in -lib directories only if it doesn't find the needed
assembly in MONO_PATH first.  On the other hand, using a full path with -r will
take priority over the assemblies in system directories.

[mini] Run tests with --runtime=mobile for testing_aot_full profile

[runtime] Redirect mobile System.Net.Http to version 4.0.0.0

per mcs/class/System.Net.Http/Assembly/AssemblyInfo.cs
our System.Net.Http AssemblyVersion is 4.0.0.0 when using mobile.

[Mono.Options] Update documentation build

[Mono.Options] Add Mono.Options.Command, .CommandSet

Mono.Options.CommandSet allows easily having separate commands and
associated command options, allowing creation of a *suite* along the
lines of **git**(1), **svn**(1), etc.

CommandSet allows intermixing plain text strings for `--help` output,
Option values -- as supported by OptionSet -- and Command instances,
which have a name, optional help text, and an optional OptionSet.

var suite = new CommandSet ("suite-name") {
// Use strings and option values, as with OptionSet
"usage: suite-name COMMAND [OPTIONS]+",
{ "v:", "verbosity", (int? v) => Verbosity = v.HasValue ? v.Value : Verbosity+1 },
// Commands may also be specified
new Command ("command-name", "command help") {
Options = new OptionSet {/*...*/},
Run     = args => { /*...*/},
},
new MyCommandSubclass (),
};
suite.Run (new string[]{...});

CommandSet provides a `help` command, and forwards `help COMMAND`
to the registered Command instance by invoking Command.Invoke()
with `--help` as an option.

[mkbundle] Fixes the embedding of dependency assemblies + test

Fix the build.

[coop handles] Assert if interior ptr handle passed to mono_gchandle_from_handle

[coop handles] Use a bitmap per HandleChunk to track interior ptr handles

instead of using a flag byte in each HandleChunkElem.

[reflection] Use coop handles for MonoMethodInfo.get_method_info and MonoPropertyInfo.get_property_info

[marshal] Pin valuetype ref icall arguments.

There are now 4 kinds of arguments to icalls:
  1. Plain old values like 'int', 'bool', etc.  Passed from the wrapper to the
     icall as is.
  2. Objects in the managed heap.  Passed using coop handles.
  3. 'out' objects in the managed heap.  A NULL coop handle is passed in
     and its final value is written back out to the caller's out argument.
  4. Value types passed by 'ref' or 'out'.  An "interior" coop handle is created which has
     the effect of pinning the object into which the ref points (if it points
     to the stack, nothign happens).  The argument is passed to the icall as a
     raw reference (MonoFoo*, not MonoFooHandle).  The ref will be unpinned
     when the icall wrapper returns.

[coop handles] Add handles for interior pointers / valuetype handles

- Call mono_handle_stack_scan for both the precise and the imprecise gc scans.
- For now assert during scan that all handles are to the beginning of an
  object.
- Add TYPED_VALUE_HANDLE_DECL Macro to declare valuetype handles:
     TYPED_VALUE_HANDLE_DECL (MonoMethodInfo);
     /* Declare MonoMethodInfoValueHandle and MonoMethodInfoValueHandleOut */
- Add MONO_HANDLE_NEW_GET_VALPTR (h, type, field) macro to create a new handle that
  points to "field" (of type "type") in the object "h".

Make System.Drawing unit tests use Assert.Throws instead of [ExpectedException] (#4476)

* Use Assert.Throws<> intstead of ExpectedException

* System.Drawing.Tests: Use Assert.Throws instead of ExpectedException

[resx2sr] Handle duplicate keys

[sgen] use memmove as src and dst can overlap

valgrind said this on `mcs --version`:

```
==807== Thread 1:
==807== Source and destination overlap in memcpy(0x413f050, 0x413f050,
8)
==807==    at 0x4C32513: memcpy@@GLIBC_2.14 (in
/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==807==    by 0x7FB6DD: sgen_qsort_rec (sgen-qsort.c:76)
==807==    by 0x7FB8CC: sgen_qsort (sgen-qsort.c:118)
==807==    by 0x7ED834: major_free_swept_blocks (sgen-marksweep.c:2136)
==807==    by 0x7F0590: sgen_memgov_calculate_minor_collection_allowance
(sgen-memory-governor.c:114)
==807==    by 0x7F0D2E: sgen_memgov_major_collection_end
(sgen-memory-governor.c:278)
==807==    by 0x7A6C71: major_finish_collection (sgen-gc.c:2116)
==807==    by 0x7A6E23: major_do_collection (sgen-gc.c:2158)
==807==    by 0x7A7464: sgen_perform_collection (sgen-gc.c:2355)
==807==    by 0x7A85AF: sgen_gc_collect (sgen-gc.c:2854)
==807==    by 0x77C022: mono_gc_collect (sgen-mono.c:2574)
==807==    by 0x726A18: mono_domain_finalize (gc.c:439)
==807==
==807== Source and destination overlap in memcpy(0x413f078, 0x413f078,
8)
==807==    at 0x4C32513: memcpy@@GLIBC_2.14 (in
/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==807==    by 0x7FB6DD: sgen_qsort_rec (sgen-qsort.c:76)
==807==    by 0x7FB798: sgen_qsort_rec (sgen-qsort.c:92)
==807==    by 0x7FB8CC: sgen_qsort (sgen-qsort.c:118)
==807==    by 0x7ED834: major_free_swept_blocks (sgen-marksweep.c:2136)
==807==    by 0x7F0590: sgen_memgov_calculate_minor_collection_allowance
(sgen-memory-governor.c:114)
==807==    by 0x7F0D2E: sgen_memgov_major_collection_end
(sgen-memory-governor.c:278)
==807==    by 0x7A6C71: major_finish_collection (sgen-gc.c:2116)
==807==    by 0x7A6E23: major_do_collection (sgen-gc.c:2158)
==807==    by 0x7A7464: sgen_perform_collection (sgen-gc.c:2355)
==807==    by 0x7A85AF: sgen_gc_collect (sgen-gc.c:2854)
==807==    by 0x77C022: mono_gc_collect (sgen-mono.c:2574)
==807==
==807== Source and destination overlap in memcpy(0x413f088, 0x413f088,
8)
==807==    at 0x4C32513: memcpy@@GLIBC_2.14 (in
/usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==807==    by 0x7FB6DD: sgen_qsort_rec (sgen-qsort.c:76)
==807==    by 0x7FB798: sgen_qsort_rec (sgen-qsort.c:92)
==807==    by 0x7FB798: sgen_qsort_rec (sgen-qsort.c:92)
==807==    by 0x7FB8CC: sgen_qsort (sgen-qsort.c:118)
==807==    by 0x7ED834: major_free_swept_blocks (sgen-marksweep.c:2136)
==807==    by 0x7F0590: sgen_memgov_calculate_minor_collection_allowance
(sgen-memory-governor.c:114)
==807==    by 0x7F0D2E: sgen_memgov_major_collection_end
(sgen-memory-governor.c:278)
==807==    by 0x7A6C71: major_finish_collection (sgen-gc.c:2116)
==807==    by 0x7A6E23: major_do_collection (sgen-gc.c:2158)
==807==    by 0x7A7464: sgen_perform_collection (sgen-gc.c:2355)
==807==    by 0x7A85AF: sgen_gc_collect (sgen-gc.c:2854)
```

[cert-sync] Don't import into BTLS store if BTLS is not available (#4475)

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

Finalize the implementation of SignedXml.ComputeSignature(). (#4452)

* Finalize the implementation of SignedXml.ComputeSignature().

The implementation was taken from Reference Source, which makes the behaviour of this method the same as in .NET Framework, as well as makes it possible to use custom signature descriptions.

[jit] Fix an assert in mono_unwind_ops_encode_full () caused by an off-by-one error. Fixes #53066.

[arm64] Fix the passing of small arguments on the stack in the gsharedvt trampoline, the calculation of their stack offset was incorrect in two places. Fixes #52866.

[msvc] Update csproj files (#4474)

[metadata] Fix a possible crash when looking up a p/invoke function. (#4471)

It's possible for two threads to modify the same MonoMethodPInvoke.addr
in mono_lookup_pinvoke_call, with one thread setting it to NULL inside the
loop, and the other thread having completed the loop and expecting it to
be non-NULL.

Use an intermediate variable to prevent addr becoming non-NULL.

[corert] Import System.Threading.ThreadPoolBoundHandle

[corert] Import System.Diagnostics.Debug

[System.Core] Collections from corefx

[mono/tests] run the managed test runner using TOOLS_RUNTIME

The test runner itself should use the tools runtime, but the AOT step and the
tests themselves will be launched in the profile that's being tested.

[fullaot] configure.ac: pass --runtime=mobile to AOT_{BUILD,RUN}_FLAGS

For the profiles where we compile the BCL with -d:MOBILE, (where the
`[assembly: AssemblyVersion (Consts.FxVersion)]` attribute ends up pointing to
the mobile version) make sure we AOT and run the tests using the mobile
runtime.  This ensures that for the framework assemblies the version number in
the assembly matches the version number that the internal runtime remapping (
`mono/metadata/assembly.c` `framework_assemblies` array)

[threads] Remove ThreadState_StopRequested (#4462)

[jit] Remove some duplicate declarations.

[jit] Fix MethodAccessExceptions, the caller and callee were switched. (#4465)

[threads] Remove mono_threads_create_thread (#4411)

[runtime] Fix an infinite loop in the runtime class init code. (#4455)

The following can happen:
* Thread T1 starts initialization of C1
* Thread T2 starts initialization of C2
* T2 starts initialization of C1, it gets blocked on T1.
* T1 finishes initializing C1.
* T1 starts initialization of C3.
* T1 starts initialization of C2. It sees that T2 is
  still blocked on T1, but its not actually blocked, since
  C1 is finished. Still, we record that T1 is blocked.
* T3 starts initialization of C2, it gets into an infinite
  loop in the while loop, since the blocked_thread_hash
  now indicates that T1 and T2 are blocked on each other.

The solution is to not mark a thread as blocked, if its waiting
for a thread which is waiting on a finished lock. Fixes hangs
when running csc.

[threads] Remove dead field cached_culture_info (#4410)

Fixes to build libmono with disabled JIT. (#4421)

Current mono build on (at least Windows) fails if build with disabled JIT
since the .def file used when building libmono, mono-2.0-sgen.dll, exports
a couple of symbols missing when DISABLE_JIT is defined.

Turns out that these methods have been incorrectly exported and should not
be part of the public API surface. This commit removes MONO_API for the
methods incorrectly marked:

mono_emit_native_call
mono_inst_name
mono_replace_ins

It also removes them from the .def files so they won't be exported in the
mono runtime DLL on Windows.

For mono_set_break_policy an empty stub will be added since it is considered
being a public API.

The above support is primarily used on none desktop Windows platforms
when building mono runtime module without JIT support.

This commit also fix a problem introduced in tramp-amd64.c by commit
https://github.com/mono/mono/commit/4281399ba4b7c44a30fa2c2a314a470260bb3eb1
causing it to get duplicated definitions of mono_arch_get_enter_icall_trampoline
when DISABLE_JIT has been defined.

Merge pull request #4454 from kumpera/allow_sioc_with_managed_impl

Allow banned assemblies with LoaderFrom

Find more libraries via dllmap (#4451)

This allows centralized configuration of library paths. For instance,
previously setting path to libgtk-x11-2.0 won't make all parts of Mono use
provided library.

Change clock source to CLOCK_MONOTONIC in 'pthread_cond_timedwait'

 Wait functions for Mutex, Semaphore and Condition (like pthread_cond_timedwait) for 'task' synchronisation in Linux uses CLOCK_REALTIME by default,
this creates many problems where a process changes time. e.g. Command line utility < date -s "desired date and time" >
A thread may be blocked for a more\less time depending upon time change. It is always desirable to use clock source immune to such changes
However, it is not possible to change clock source for mutex and semaphore wait functions in Linux. So changing it for condition only

This can be seen by a simple application if you make a simple timer using System.Timers.Timer and print time stamp every regular interval say 2 seconds, now if time shifts in the system for whatever reason ( you can do this in Linux by <sudo date -s "Wed Oct 26 20:25:24 IST 2016"> put desired time in quotes), this print stops coming for the offset time duration.

The reason behind this is the call to 'pthread_cond_timedwait' function, by Timer class which uses it to sleep for timeout duration. Now this function uses CLOCK_REALTIME which can be changed, so if you change this clock, a thread will be blocked for the unexpected time. So using CLOCK_MONOTONIC removes the error.

There are many embedded systems which do not have RTC and rely upon the external time like systems using GPS or set top box. So this fix is inevitable for them, at least for condition variable wait.

This is the sample code
using System;
using System.Timers;

public class Example
{
private static System.Timers.Timer aTimer;

public static void Main()
{
SetTimer();

Console.WriteLine("\nPress the Enter key to exit the application...\n");
Console.WriteLine("The application started at {0:HH:mm:ss.fff}", DateTime.Now);
Console.ReadLine();
aTimer.Stop();
aTimer.Dispose();

Console.WriteLine("Terminating the application...");
}

private static void SetTimer()
{
// Create a timer with a two second interval.
aTimer = new System.Timers.Timer(2000);
// Hook up the Elapsed event for the timer.
//((System.ComponentModel.ISupportInitialize)(aTimer)).BeginInit();
aTimer.Elapsed += OnTimedEvent;
//((System.ComponentModel.ISupportInitialize)(aTimer)).EndInit();
aTimer.AutoReset = true;
aTimer.Enabled = true;
}

private static void OnTimedEvent(Object source, ElapsedEventArgs e)
{
Console.WriteLine("__The Elapsed event was raised at {0:HH:mm:ss.fff}",
                  e.SignalTime);
}
}

This updates and merge https://github.com/mono/mono/pull/3828

[msvc] Update csproj files (#4461)

Bump cecil

[threads] Remove mono_threads_suspend_needs_abort_syscall (#4450)

[runtime] Cleanup the debugger header files. (#4459)

* Rename debug-mono-debugger.h to debug-internals.h.
* Move the internal debug structures to debug-internals.h from debug-mono-symfile.h.

Merge pull request #4418 from kumpera/fix_gclass_recording_on_failure

[loader] When loading the parent of a GTD fails. We must disable gclass recording for it.

[runtime] Use mono_debug_method_lookup_location () instead of mono_debug_symfile_lookup_location (), the latter doesn't support portable pdb files. Use mono_debug_free_source_location () for freeing. Fixes #52899. (#4457)

[corlib][System] Concurrent collections from corefx

[threads] Remove unused mono_thread_internal_stop (#4449)

[loader] Revert allowing SIOC 4.3. This is fine for now as we support LoadFrom as a work-around.

[loader] Pass LoadFrom down to image loading so we can make decisions based on that.

Pass LoadFrom info down to assembly loading.

Merge pull request #4373 from NattyNarwhal/haiku

Restore Haiku support

[runtime] SIOC 4.3.0 has a managed impl that works under mono. Don't ignore it.

[tools] Update nuget hash extractor so we don't block SIOC 4.3.0.

[interpreter] rename interpreter to interp

for folks without autocompletion :P

[generics.cs] enable more testcases for interpreter

[interpreter] use explicit addressing for stack slots

[interpreter] add basic-vectors.cs to richeck target

[interpreter] add {exceptions,devirtualization,basic-simd}.cs to richeck target

[interpreter] add floating point support to icall trampoline, add basic-math.cs to richeck target

[interpreter] add arrays.cs to richeck target

[objects.cs] enable last two remaining tests for interpreter

\o/

[interpreter] fix array built-ins wrt. multiarray access

[interpreter] fix metadata access for ldtoken insn in wrappers

[interpreter] implement ref type for ldelem bytecode

[interpreter] install stack walking callback

[interpreter] it can happen that we have the address of a enum on the stack, and we need to dereference it before we box it.

[interpreter] allow generic inst type in icall trampoline

[interpreter] if unboxing is required on virtcall, point into object instead of copying

[generics.cs] test calling an interface, that's implemented by a generic value type

[interpreter] properly inflate method on generic virtual call

[interpreter] inflate method signature for delegate.invoke ()

[interpreter] inflate signature for calli with proper generic_context

[object/interpreter] add trap for future pitfalls

[interpreter] add init_delegate callback

and set `method` field in delegate

[interpreter] use jit icall for delegate ctor

[trampolines] make sure no delegate trampoline is created in interpreter mode

[objects.cs] testcase for delegate with instance method that uses `this'

[interpreter] pop extra arg in CEE_MONO_CALLI_EXTRA_ARG

Merge pull request #4440 from kumpera/fix-assembly-remapping

[runtime] Fix assembly remapping by using a hashtable. Fixes #52846 and #52743

[msvc] Update csproj files

Merge pull request #4381 from BrzVlad/feature-generational-hash

[sgen] Generational MonoGHashTable

[runtime] Fix assembly remapping by using a hashtable. Fixes #52846 and #52743

In multiple occasions we had bugs due to framework_assemblies not being correctly sorted.

Instead of just fixing the ordering again, I'm moving it a hashtable so future generations won't have to fix this for System.SpaceTravel.dll.

[System] Add regression test for Bugzilla 10899 (#4401)

Even though I couldn't repro the bug I thought it'd still be a
good idea to at least add some basic coverage with non-Latin chars.

Merge pull request #4438 from xmcclure/monodis-fix

Fix monodis

Fix monodis

monodis was not calling the mono_tls_init_runtime_keys function, which
was causing it to crash the first time it attempted to access the
current domain (ie almost immediately).

Merge pull request #4433 from kumpera/android-fixes

Fix a few issues on Android

[jit] Rewrite some logging to work on embedded systems.

[jit] Fix LMF codegen on android arm64.

Android doesn't have fast tls either, so we must use the jit_tls variant.

[alias-analysis] Ignore addresses taken of volatile variables.

Volatile variables should be ignored by AA as, by design, we can't
properly tell whether removing indirection is safe or not.

This shows up when handling the LMF var in some cases.

[runtime] Mark mono_error_init external only. (#4437)

Runtime should use the error_init() from mono/utils/mono-error-internals.h

Merge pull request #4434 from BrzVlad/fix-unload-hang

[threads] Don't ignore abort requests in abort protected blocks

Update ms-test-suite

[System.Numerics] Use corefx implementation

Merge pull request #4431 from vkargov/vk-leaking-points

[runtime] Fix memory leak in mono_save_seq_point_info().