Merge pull request #5668 from kumpera/wasm-work-p4

More WASM fixes.

[ci] Small improvements for run-jenkins and collect-coverage. (#5669)

* [ci] Allow setting custom mono flags for test runs via MONO_TEST_FLAGS.

* [ci] Make the handling of CFLAGS a bit more flexible in run-jenkins.sh.

* [ci] Generalize collect-coverage to handle more targets.

Merge pull request #5675 from mono/glib-debug-symbols

Add glib to the list of packages with debugging symbols.

Bump mono-extensions to fix build break (#5677)

The driver.c patch from mono-extensions no longer applied after https://github.com/mono/mono/commit/30cddad5fb4c3d290906a6e6c33ecd8b07d8b48c

Bump NuGet.BuildTasks to get new updates and switch to `dev` branch (#5566)

Add glib to the list of packages with debugging symbols.

[profiler] log profiler: limit method instrumentation to selected methods (#5517)

* [trace] remove code that has no effect

* [trace] move program assembly out of MonoTraceSpec

The assembly member represents the program assembly. It's
information the trace spec is matched against, not part of
the trace spec per-se (if two trace specs exist for two purposes
we would still have one program assembly)

* [trace] remove side effects from get_string()

On the way towards supporting multiple trace specs,
remove side effects from get_string() function.

* [trace] remove side effects from get_token()

Remove side effects from get_token() to allow handling
multiple trace specs.

* [trace] fix handling of double exclusion and disabled

When encountering "disabled", do not add an entry to
the trace spec

Fix error handling around double "-" - get_spec()
never returns TOKEN_EXCLUDE and the recursion can
be easily avoided.

* [trace] remove side effects from get_spec()

Another step in making the trace options reusable.

* [trace] rename mono_trace_parse_options() to mono_trace_set_options()

This routine actually sets the tracing options, not just parses an
option string, so set_ is more suitable. This frees up the
mono_trace_parse_options() name for pure parsing, when we later
reuse the parsing code.

* [trace] make tracing options API reusable

Add APIs that parse tracing options and evaluate a method
against the parsed options. The tracing functionality now uses
this API, but other components can use this to apply an operation
to a method based on policy (e.g. profiling)

* [trace] rename MonoTraceSpec to MonoCallSpec

In preparation for reusing call specification beyond the
tracer, rename the data structure - it now only specifies
a set of calls, without indication what should be done with
them.

* [trace] rename mono_trace_set_assembly to mono_callspec_set_assembly

As it becoming a reuse candidate, we remove the "trace" component
from the name.

* [trace-metadata] move callspec code into its own module

Introduce callspec.c/h which encapsulate the call specification
functionality.

* [profiler] add "callspec" option to log profiler

The callspec option define which methods get instrumented
at JIT time with entry/exit calls to the profiler. The
syntax is same as the tracer (--trace=) syntax. To
distinguish between profiler options and callspec, wrap the
callspec with double quotes, as in:
--profile=log:callspec="all-mscorlib",calls

Since this typically runs from a shell, the double quotes have to be
escaped or wrapped in single quotes, as in:
mono '--profile=log:callspec="all-mscorlib",calls' prog.exe

* [metadata] add an error return string to callspec parsing

Instead of printing parsing error messages to standard error,
return an error string. That allows the client to do the right thing
with the error.

[jit] Fix the saving of the 'cfg->ret_var_set' flag when inlining, it was set to FALSE before it was saved, causing invalid code to be generated in some cases when doing nested inlining. Fixes #59608. (#5654)

[mcs] Initial by ref returns and variables support

Fix ninja BTLS build for verbose builds (#5673)

ninja treats `VERBOSE=1` as a target and, failing to find one, aborts
the build with an error. Pass `-v` in this case instead.

Fix LinearGradientMode parameter validation to match corefx (#5672)

Allow passing null to JsonArray.Add()

null is a valid value in a JSON array, so there is no reason forbid
adding null to the array. JsonArray.Save() already handles null values in
the array.

Remove invalid tests for image palettes in GdiPlusTest (#5671)

C.r. https://github.com/mono/libgdiplus/pull/112

[corlib] Make Marshal.BufferToBSTR(Array, int) non-public again (#5670)

* [corlib] Make Marshal.BufferToBSTR(Array, int) non-public again

It was accidentally made public in https://github.com/mono/mono/commit/c5cdfaec1e0973ced3f97ef589cd0bece56067ad.
Unfortunately this was before we had the API diff check on Mono and the manual checks in XI/XA integration didn't catch it either.

* Bump API snapshot submodule

Merge pull request #5659 from kumpera/fix_59824

[runtime] Synthesize IList and IReadOnlyList for the element type of enum errays. Fixes #59824

[wasm] We can't free memory in wasm as it uses the malloc mmap backend.

[wasm] Add new missing signature.

[wasm] Disable test that doesn't work with WASM

[System.Net.Http] HttpClient timeout range checks. Fixes #25755

codeowners update

[w32file] Move MonoIO.Find{First,Next,Close} to managed

[w32file] Remove dead code

[sre] register a canonical MonoReflectionMethod for a methodref token

In mono_image_create_token we are passed in a managed reflection object and we
need to create a token for it and optionally register it so that we can resolve
that token back to a runtime structure and managed object later.

For a MonoReflectionMethod object that refers to a method from outside the
current dynamic image, we need to generate a memberref token.  It will be the
same token for the same underlying MonoMethod*.  When we go to register the
token with mono_dynamic_image_register_token we need to pass a managed object.
Unfortunately two MonoReflectionMethod objects could refer to the same
MonoMethod* but differ in their ReflectedType, so just registering the
passed-in MonoReflectionMethod means we could assert in
mono_dynamic_image_register_token because previously we may have registered the
same method via a different ReflectedType.

So what we do is we cal mono_method_get_object_handle with NULL for the
reflected type - which corresponds to just using the DeclaringType of the given
MonoMethod*.

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

[sre] Expect a new token for MonoArrayMethod and SignatureHelper

[sre] Remove MonoDynamicImage:handleref_managed field

It's now unused.

[sre] Map fieldref tokens to MonoClassField*

Previously, we mapped fieldref tokens to MonoReflectionField managed objects,
But the object is just used as a key for caching the token so we may as well
use the native field instead of a managed object.

[sre] Wrap mono_image_create_token with HANDLE_FUNCTION_{ENTER,RETURN}

We will allocate a handle for the object that we will register.  For now it's
just an alias of the object passed in, but it could differ.

[test] SRE ILGenerator test for methodref and fieldref token caching

Regression test for https://bugzilla.xamarin.com/show_bug.cgi?id=59364

We need to cause SRE to generate the same methodref/fieldref token from two
different reflection objects.  That happens if you get the same method or field
via a base and a derived class so that the MemberInfo:DeclaredType is different
but the underlying MonoMethod* or MonoClassField* is the same.

[System] HttpListenerRequest: ignore bad cookies and keep request alive (#5657)

HttpRequestListener throws on incorrect cookie name. It throws CookieException ("Name contains invalid characters"). There are many cookies out there that unfortunately do not conform to the guidelines and HttpRequestListener will kill the request in such a case. The .Net framework under windows lets the request through however.

Included is a patch HttpListenerRequest as well as a test with a bad cookie name.

I have tested this under linux(master branch) and .net (4.0), they now both have the same behavior.

[msbuild] Bump msbuild to fix test failures on wrench (#5660)

Merge pull request #5560 from kumpera/wasm-work-p3

More WASM fixes, with this I can get half of the mini test suite to run without crashing.

Merge pull request #5567 from kumpera/fix_59334

[runtime] Handle RuntimeWrappedException and dynamic methods. Fixes #59334

[runtime] Synthesize IList and IReadOnlyList for the element type of enum errays. Fixes #59824

Make sure array of enums can be casted to interfaces of their element types.

[mini] Fix test compiling when running !MOBILE

[runtime] Fix icall signature and change comment to fixme.

[wasm] Implement GC support. Embedder must provide main loop pumping function request_gc_cycle.

[runtime] Fix DISABLE_REFLECTION_EMIT build.

[mkbundle] Link against Objective-C runtime and Foundation framework on OSX (#5642)

Without it you get errors like the following in old-style mkbundle:

```
Undefined symbols for architecture x86_64:
  "_CFLocaleCopyCurrent", referenced from:
      _ves_icall_System_Globalization_CultureInfo_get_current_locale_name in libmono-2.0.a(libmonoruntimesgen_la-locales.o)
  "_CFLocaleGetIdentifier", referenced from:
      _ves_icall_System_Globalization_CultureInfo_get_current_locale_name in libmono-2.0.a(libmonoruntimesgen_la-locales.o)
  "_CFLocaleGetValue", referenced from:
      _ves_icall_System_Globalization_CultureInfo_get_current_locale_name in libmono-2.0.a(libmonoruntimesgen_la-locales.o)
  "_CFRelease", referenced from:
      _ves_icall_System_Globalization_CultureInfo_get_current_locale_name in libmono-2.0.a(libmonoruntimesgen_la-locales.o)
...
```

We actually documented this in the 3.4 release notes: http://www.mono-project.com/docs/about-mono/releases/3.4.0/#breaking-changes

However this means that you had to use the "-c" mkbundle option
to only generate the .c stub so you could pass those additional libraries.

[jit] Add support for unlimited size/number of arguments to the dyn call code (#5612)

* [jit] Add a mono_arch_dyn_call_get_buf_size () arch specific function which returns the size of the buffer required for a given dyn call. Use this instead of a fixed size buffer, to allow backends to use variable sized buffers later.

* [amd64] Add support for unlimited size/number of arguments to the dyncall code.

* [arm64] Add support for unlimited size/number of arguments to the dyncall code. Part of the fix for #59184.

[[runtime] Wait for the thread to really exit in Thread.Join (). Change the check for started threads in mono_thread_set_name_internal () so it check the thread state and not the tid. Avoid setting the tid to 0 when the thread exits. (#5549)

[mini] Add my test suite to the list of magic type assemblies.

[mini] Adjust some test suites to work under mobile.

[Mono.Unix] Fix crasher in StringToHeap (#5639)

In case StringToHeap (string, Encoding) was called with a null string, it would unconditionally reference the string when trying to query the string's length.

Bug 10074 - Error while updating status of command: MonoDevelop.Ide.Commands.ViewCommands.LayoutList

[test] Add gparam Type.IsAssignableFrom and Type.BaseType tests

Lock down .NET Framework documented behavior

[class] Use constraints of gparam T2 in T1.IsAssignableFrom (T2)

Suppose we want to know C.IsAssignableFrom (T1):
```
  class C { }
  class G<T1, T2> where T1 : T2, T2 : C { }
```

Previously, we would get `False`, because we only checked the constraints of T1
if C was an interface or another gparam.  Now Instead we always consider the
constraints in `A.IsAssignableFrom (B)` whenever `B` is a gparam.

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

[test] Add regression test for 58809

Check that generic parameters's constraints properly affect the subclass and
interface relationships even when the constraints relate several of the generic
parameters themselves.

[w32process] Fix inverted kernel and user ticks (#5641)

Fix shutdown race between mono_thread_manage and mono_thread_detach_internal. (#5599)

* Add support for mono_threads_add_joinable_thread and friends on Windows.

Current Windows implementation doesn't have support for the joinable thread
implementation in threads.c. Joinable threads are used by the runtime during
shutdown to coordinate with exit of platform threads.

Since threads detaching and exiting during shutdown could still use or provide
important resources, like GC memory, lacking support for this feature could
potentially expose the implementation to various shutdown race conditions.

Commit also change requested permission on a thread handle when opening it for
synchronization purposes. No need to request all thread access when handle is only
used for synchronization, like in WaitForXXX API calls.

* Fix race between mono_thread_detach_internal and mono_thread_manage.

There is a race during shutdown when main tread is running mono_thread_manage and
attached threads are running mono_thread_detach_internal. The problem is related to
the removal from the registered threads list since mono_thread_manage will pick
threads to wait upon from that list. If a thread removes itself from the list
using mono_thread_detach_internal it will then race against runtime shutdown
and the removal of used resources still in used by mono_thread_detach_intenral,
like MonoInternalThread.

This race could trigger the assert seen in bugzilla:

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

or other undefined behavior depending on where the detached thread resume execution
after main thread has shutdown the runtime, but not yet terminated the process.

The fix makes sure threads that are detaching during shutdown ends up on the joinable
threads list. Threads on that list will be waited upon by the main thread during shutdown,
mono_thread_cleanup. This will make sure the detached thread finishes the remaining of
mono_thread_detach_internal and potential other code still using GC memory during shutdown.
Threads already on the threads list will already be waited upon by mono_thread_manage during
shutdown (if not removed by mono_thread_detach_internal triggering this race), so this change
won't add additional threads to be waited up by the runtime. It just makes the shutdown more
reliable using already available concepts (like the joinable threads list).

* Fix warning C4141 on Windows MSVC compiler.

* Updated with review feedback.

* Prevent race between finalizer and main thread to join same thread multiple times.

Checking against joinable_threads list in mono_threads_add_joinable_thread is not enough.
There is a small chance that the same runtime thread could get on the list twice since
mono_threads_add_joinable_thread could be called multiple times for the the same tid.
This will work under Windows but is undefined behavior on POSIX's platforms.

This could happen if the finalizer thread calls mono_threads_join_threads when a thread
is detaching and have added itself to the joinable_threads, but before unregister_thread
has been called. Finalizer thread will then take tid from list and wait, this will cause
the second call to mono_threads_add_joinable_thread to not find itself in the joinable_threads
and add tid a second time. NOTE, this race only applies to runtime threads added to the
joinable_threads list.

Fix adds an additional method to add runtime threads to the list. This method will only add to
list if its indeed a runtime thread and doesn’t already have an outstanding pending native join
request. This method is called by code previously checking runtime_thread flag before adding to
joinable_threads list. This will prevent the scenario when the same MonoThreadInfo add its tid to
the joinable_threads list multiple times due to above race condition.

Merge pull request #5640 from alexrp/master

[profiler] Fix some buffer size calculations.

[profiler] Fix some buffer size calculations.

[Tests] Fail with message in case symlink fails

Merge pull request #5433 from lateralusX/lateralusX/windows-mono-debugger-soft-hang

Fix sporadic hang in Mono.Debugger.Soft test suite on Windows.

[w32handle] Only own first handle if doing WaitHandle.WaitAny (#5625)

This is the behaviour on .NET, even if it goes against the documentation at https://msdn.microsoft.com/en-us/library/tdykks7z(v=vs.110).aspx#Anchor_2

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

[wasm] Disable test due to emcc bug.

[wasm] Fix test_0_conv_i under interp.

[mini] Fix bug categories.

[wasm] Add ff signature

[interp] Don't inline empty calls that take vt arguments.

[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.

[class] Short circuit collect_implemented_interfaces_aux on gparams

and also setup_interface_offsets.

A gparam is never a real interface so we can just short circuit
if we see a gparam during interface collection.  (A gparam may be instantiated
with an interface --- but ginst interface offsets are processed anew when the
ginst is initialized in mono_class_init, not somehow extracted from the gtd and
the MonoGenericContext).

[class] Mark mono_class_from_generic_parameter external only

Runtime should use mono_class_from_generic_parameter_internal

[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

Updated with review feedback.

Added file license header and updated comments.

Fixed typo in call to SignalObjectAndWait.

Fix sporadic hang in Mono.Debugger.Soft test suite on Windows.

Mono.Debugger.Soft has low frequency hangs in InspectThreadSuspenedOnWaitOne test.
This method launch the debuggee (dtest-app.exe), sets a breakpoint on a method just
doing an infinite OS wait, validate that the breakpoint gets hit and resumes debuggee.
After resume from breakpoint debuggee will hit the infinite OS wait and the debugger test
will suspend and shutdown the process.

In order for mono debugger to handle the shutdown request it will suspend all managed threads
using mono_thread_suspend_all_other_threads. This method uses a pooling schema until all threads
have reported that they are suspended. Since one of the threads are doing an infinite OS wait we
entered the land of APC (Asynchron Procedure Calls) used on Windows to alert waitable threads.

The reason for the hang is the fact that the OS won’t return from the wait until all queued APC’s
have been executed. Since the loop sending async suspend requests to the
threads mono_thread_suspend_all_other_threads can run faster (including suspending/resuming the
thread that need to consume APC’s in the process) then the dequeue and execute of the queued APC’s, the
wait won’t break, meaning that the thread won’t be able to set the mono suspend state causing the
mono_thread_suspend_all_other_threads to run forever. This is highly timing dependent and will only reproduce
sporadic, but I was able to isolate and do a solid repro locally while working on the fix.

The fix makes sure we don’t post a new suspend APC if there is already one in flight with a pending unhandled
interruption. This will make sure we won’t flood the APC queue on Windows preventing the thread from suspending.

[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