Merge pull request #2831 from razzfazz/fix_dllimport

clean up DllImport attributes

[System] Always pass -noconfig to codedom c# compiler

[build] Exclude generated .g.cs files from "make dist"

The recent changes to the mobile profiles introduced generated files in their .sources like CommonCrypto/MD5CryptoServiceProvider.g.cs
However, those are not generated when the mobile profiles aren't enabled at configure time.

This caused a problem during "make dist" since it tries to grab the entries in .sources from *all* profiles, causing errors like:

    cp: cannot stat ‘CommonCrypto/MD5CryptoServiceProvider.g.cs’: No such file or directory
    make[5]: *** [dist-local] Error 1

The easiest fix is to filter out those generated files.

clean up DllImport attributes

Any native function that can modify errno should have the
SetLastError attribute set to true. Also, no need to specify
EntryPoint if it's the same as the function name.

[runtime] Allow the options in MONO_DEBUG to be passed as a command line option too.

[llvm] Enable pinvoke call using the C calling conv in llvm-only mode.

[corlib] Make some ExceptionDispatchInfo tests with BitcodeNotWorking because we don't truncate stack traces of exceptions at the catch site when running with bitcode.

Merge pull request #2827 from xmcclure/profile-clean-0.1

Continued profiler loading cleanup (PR#2816 follow up)

Merge pull request #2545 from ermshiperete/Xamarin-24974

[corlib] Fix exception in __ComObject finalizer during shutdown

* keep a reference to a __ComObject's proxy so it doesn't get garbage
  collected
* don't create __ComObjects unnecessarily
* Fix for bug [24974](https://bugzilla.xamarin.com/show_bug.cgi?id=24974)

[build] Update nunit-console path for xbuild profiles

[Microsoft.Build.Engine] Update test files

[mcs] Make more errors build explicit

[System.Runtime.Serialization.dll] Update referencesource strings

[tools] Update missing reference

Fix make dist

[test-runner] Ignore exceptions during process kill

We hit this on Jenkins over the weekend:
https://jenkins.mono-project.com/job/test-mono-mainline/label=osx-amd64/3845/parsed_console/log_content.html#WARNING1

```
Unhandled Exception:
System.InvalidOperationException: Cannot process request because the process (51792) has exited.
  at System.Diagnostics.Process.GetProcessHandle (Int32 access, Boolean throwIfExited) <0x10d7ea000 + 0x001b6> in <filename unknown>:0
  at System.Diagnostics.Process.GetProcessHandle (Int32 access) <0x10d7f2fd0 + 0x0001e> in <filename unknown>:0
  at System.Diagnostics.Process.Kill () <0x10d7f2ee0 + 0x00031> in <filename unknown>:0
  at (wrapper remoting-invoke-with-check) System.Diagnostics.Process:Kill ()
  at TestRunner+<Main>c__AnonStorey0.<>m__0 () <0x10a9b50b0 + 0x00e30> in <filename unknown>:0
  at System.Threading.ThreadHelper.ThreadStart_Context (System.Object state) <0x10c55bc90 + 0x0009a> in <filename unknown>:0
  at System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, Boolean preserveSyncCtx) <0x10c55a210 + 0x001c6> in <filename unknown>:0
  at System.Threading.ExecutionContext.Run (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, Boolean preserveSyncCtx) <0x10c55a1e0 + 0x00020> in <filename unknown>:0
  at System.Threading.ExecutionContext.Run (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state) <0x10c55a130 + 0x00059> in <filename unknown>:0
  at System.Threading.ThreadHelper.ThreadStart () <0x10c55be50 + 0x0002e> in <filename unknown>:0
[ERROR] FATAL UNHANDLED EXCEPTION: System.InvalidOperationException: Cannot process request because the process (51792) has exited.
  at System.Diagnostics.Process.GetProcessHandle (Int32 access, Boolean throwIfExited) <0x10d7ea000 + 0x001b6> in <filename unknown>:0
  at System.Diagnostics.Process.GetProcessHandle (Int32 access) <0x10d7f2fd0 + 0x0001e> in <filename unknown>:0
  at System.Diagnostics.Process.Kill () <0x10d7f2ee0 + 0x00031> in <filename unknown>:0
  at (wrapper remoting-invoke-with-check) System.Diagnostics.Process:Kill ()
  at TestRunner+<Main>c__AnonStorey0.<>m__0 () <0x10a9b50b0 + 0x00e30> in <filename unknown>:0
  at System.Threading.ThreadHelper.ThreadStart_Context (System.Object state) <0x10c55bc90 + 0x0009a> in <filename unknown>:0
  at System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, Boolean preserveSyncCtx) <0x10c55a210 + 0x001c6> in <filename unknown>:0
  at System.Threading.ExecutionContext.Run (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, Boolean preserveSyncCtx) <0x10c55a1e0 + 0x00020> in <filename unknown>:0
  at System.Threading.ExecutionContext.Run (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state) <0x10c55a130 + 0x00059> in <filename unknown>:0
  at System.Threading.ThreadHelper.ThreadStart () <0x10c55be50 + 0x0002e> in <filename unknown>:0
make[1]: *** [test-generic-sharing-managed] Error 1
```

We can't do anything about those errors, so just catch and ignore it.

[build] Update mcs path in mini tests

[Facades] Update list of full assemblies

[mcs] Basic boostrap references are always default ones

[Microsoft.Build.Engine] Simplify bd70a55ec7aaeb40b2b0054e0f162c709085842f

[Microsoft.Build.Engine] clean/copy mdb files as well

[build] Change the way how mcs references are passed to compiler to always use full path.

One of csc prerequisites because csc uses -lib as path which is considered after
RuntimeEnvironment.GetRuntimeDirectory which makes -lib useless

[System.Runtime.Serialization.Formatters.Soap] Make test output deterministic

[Mono.C5] Make test output deterministic

Merge pull request #2713 from gregoryyoung/master

handles AwaitAsync finishing synchronously

[amd64] Add a separate ArgStorage entry for gsharedvt return types instead of using a separate flag in CallInfo.

[acceptance-tests] Fix test-runner.exe compilation after 136dd0

Merge pull request #2720 from mono/fix-39325

[Profiler] Keep a reference to assemblies while coverage is running

In certain circumstances, for example when running under nunit-console, assemblies could be unloaded while the profiler still had a reference to them in order to generate the coverage data. In these cases, the memory referred to by the profiler would be invalid and would crash.

Fix this by incrementing the reference count of the assemblies preventing them from being unloaded while coverage is being collected.

Fixes BXC #39325

[runtime] Move the test for shutting down the stat profiler to mini_cleanup ().

[arm64] Fix the generation of static rgctx trampolines when using aot on linux.

[arm64] Implement handler block guard trampolines.

[runtime] Fix a crash when shutting down the sampling thread.

[tests] Increase the timeout in the test runner so running tests with llvm doesn't time out.

[metadata] Remove invalid Win32 entry in object-offsets.h

The lmf_addr field in MonoLMF only exists for TARGET_X86.

[mini] Remove duplicate stubs from tramp-amd64/x86-gsharedvt.c

They already exist in arch-stubs.c and caused conflicts on the MSVC build.

[msvc] Add missing files to MSVC project files

[mini] Fix build on systems without clock_nanosleep ().

[jit] Handle verification failing with  InvalidProgramException. Fixes #40040.

[runtime] Make a copy of the types passed to mono_mb_add_local () earlier since they could be transient.

[arm64] Fix clearing of stack traces when an exception is rethrown. Fix the calculation of struct sizes in pinvoke calls. Remove some dead code.

Continued profiler loading cleanup (PR#2816 follow up)

- Back out MONO_PROFILER_LIB_DIR change
- Profiler loading traces should use log mask “dll” not “asm”
- mono_dl_open_runtime_lib should preempt standard paths when loading
  profiler
- mono_dl_open_runtime_lib should check in profiler library directory
- mono_dl_open_runtime_lib contained a memory leak
- With above changes, ptestrunner.pl can remove some environment
  massaging

Merge pull request #2825 from kumpera/loader_error_removal

GOOD RIDDANCE LOADER ERROR

Merge pull request #2826 from mattleibow/mono.options-update

[Mono.Options] Added support for Enums in the PCL version

[System.Web.Extensions] Add test for last fix

[System.Web.Extensions] Use CultureInfo.InvariantCulture for number parsing

Fixes #4242, see bug comments. JsonSerializer seems to have been already
fixed in abe9dc62. The JsonDeserializer number conversion is now much
stricter, allowing only integer number style for integers and float number
style for floats.

Merge pull request #2805 from alexrp/profiler-sampling-thread2

[profiler] Use a background thread to send out sampling signals.

Previously, when using an interval timer, the initial profiling signal could be
delivered to *any* thread in the process. This is not normally a problem, but
if the signaled thread has not even finished its initialization inside libc, it
can happen that it hasn't even set up thread-local storage yet. We then blow up
spectacularly when trying to back up errno in the SIGPROF signal handler, as
it's a TLS variable. Even the SIGSEGV handler blows up immediately after as it
can't access JIT TLS data.

Since there appears to be no reliable and portable way for a library like Mono
to control which exact thread gets the initial timer signal, instead switch to
using a background thread that uses a high-resolution sleep and attempts to
switch itself to real time scheduling if possible. This way, we have full
control over which threads we send SIGPROF to, letting us avoid any threads
which aren't in a 'good' state for profiling.

This commit also gets rid of the multiplexing that was going on in the SIGPROF
signal handler, since we now send out the signals from a background thread. As
this was the only use of the async job API, that API has been removed. This
indirectly fixes the signal storming issue that sometimes popped up, where for
some reason multiple threads would think that they're the initiating thread,
resulting in way too many signals going out.

A nice side-effect of doing the signaling ourselves is that we can now use
real-time signals on systems that have them (e.g. Linux), resulting in a nearly
100% signal delivery rate in all cases. Previously, we would lose a tremendous
amount of signals when an application was under heavy load.

[arm64] Implement interruption checking in the trampoline code.

[Mono.Options] Added support for Enums in the PCL version
 - Support for String to Enum
 - Support for Number to Enum
 - Support for Flags to Enum
 - Added a UnitTest

[profiler] Use a background thread to send out sampling signals.

Previously, when using an interval timer, the initial profiling signal could be
delivered to *any* thread in the process. This is not normally a problem, but
if the signaled thread has not even finished its initialization inside libc, it
can happen that it hasn't even set up thread-local storage yet. We then blow up
spectacularly when trying to back up errno in the SIGPROF signal handler, as
it's a TLS variable. Even the SIGSEGV handler blows up immediately after as it
can't access JIT TLS data.

Since there appears to be no reliable and portable way for a library like Mono
to control which exact thread gets the initial timer signal, instead switch to
using a background thread that uses a high-resolution sleep and attempts to
switch itself to real time scheduling if possible. This way, we have full
control over which threads we send SIGPROF to, letting us avoid any threads
which aren't in a 'good' state for profiling.

This commit also gets rid of the multiplexing that was going on in the SIGPROF
signal handler, since we now send out the signals from a background thread. As
this was the only use of the async job API, that API has been removed. This
indirectly fixes the signal storming issue that sometimes popped up, where for
some reason multiple threads would think that they're the initiating thread,
resulting in way too many signals going out.

A nice side-effect of doing the signaling ourselves is that we can now use
real-time signals on systems that have them (e.g. Linux), resulting in a nearly
100% signal delivery rate in all cases. Previously, we would lose a tremendous
amount of signals when an application was under heavy load.

[Mono.Security] Remove leftover .sources files

[runtime] Remove mono_loader_clear_error, mono_loader_assert_no_error and set_failure_from_loader_error. The loader error is no more.

[runtime] Remove mono_loader_get_last_error, nothing produces loader errors anymore.

[runtime] Remove mono_loader_error_prepare_exception, nothing can produce loader errors anymore.

[runtime] Remove all functions that set the loader error. It's dead code now.

[mono-error] Remove mono_loader_set_error_from_mono_error, nothing uses it.

[mono-error] Since nothing sets the loader error anymore, mono_error_set_from_loader_error can be removed.

Fix warnings/remove dead code.

Fix a warning.

[runtime] Fix the arm linux build by using the fallback InterlockedCompareExchange64 () implementation for now.

[runtime] Fix some warnings/remove dead code.

[corlib] Ensure newline in .sources file

It causes build issues on .sources with #include on Linux otherwise.

[corlib] Fix monotouch_tv_runtime and monotouch_watch_runtime build

Update X509CertificateImplApple to reflect latest X509CertificateImpl changes.

(cherry picked from commit 2fdfbe3479b0d3d24a5471ed7032eede80e58a2d)

[reflection] Fix leak in mono_reflection_get_custom_attrs_{by_type,data_checked}

If there's an error, first call mono_custom_attrs_free, then deal with
the error.

[security-core-clr] Fixup function signature to match header

mono_security_core_clr_ensure_reflection_access_method should return a
boolean now.

Merge pull request #2816 from xmcclure/profile-clean-0

Various cleanups on profiler

3 commits:

Assist on profiler module loading

- Add a MONO_PROFILER_LIB_DIR from which profiler modules are
  dynamically loading, in case it is not the normal library path
- Add information about profiler loading to mono_trace

Comments and clarity in proflog.c

- Add comments on structures
- Rename 'data' and 'data_end' to 'cursor' and 'buf_end' in LogBuffer/StatsBuffer as the old names were confusing
- Add new assert when processing samples

Improve a safety check when writing data into StatBuffer

- The safety check should occur such that if the new value for
StatBuffer::cursor is beyond the bounds of the StatBuffer, the cursor
is not updated.

Merge pull request #2810 from kumpera/fix_hazard_free

Fix hazard free

Replace usage of mono_thread_hazardous_free_or_queue and remove it.

    mono_thread_hazardous_free_or_queue has a fundamentally broken design.

    It allows arbitrary free code to run in the context of its caller.

    The sync/async split on where it's called is not enough to know whether
    we can run free'ing code or not.

    Since in sync context we called free functions that could take locks,
    it happened that those locks conflicted with the ones already taken.

    In particular, mono_jit_info_table_free did take a domain lock and
    quite a few of the sync context calls would hold locks that must
    not be held when taking a domain lock.

    This, is practice, means that we'd need to partition the free calls
    into 3 groups: async context, reentrant context (no runtime locks held)
    and sync context (maybe some locks held).

    There was no case where reentrant context would be usable meaning,
    in practice, that all calls happens in what effectively is async context
    where free functions can't be called.

    The new design is a lot more straightforward:

    - No implicit free queue pumping
    - A pair of free functions with well defined behavior.
     mono_thread_hazardous_try_free - to be used where the caller expects the free function to be called
     mono_thread_hazardous_queue_free - to be used where the caller don't expect the free function to be called [1]
    - Explicit pumping on places that known to be ok
     Thread detach
     Finalizer thread

    [1] This might sound like a weird condition, but a lot of lock-free code
    have compensation logic that trigger free'ing during lookups.

Fix warnings.

[gsharedvt] Change the --enable-gsharedvt configure option to a no-op, its always enabled by default.

[gsharedvt] Integrate mini-generic-sharing-gsharedvt.c into mini-generic-sharing.c.

[runtime] Use mono_object_isinst_checked

    rather than mono_object_isinst.

[arm64] Fix passing of small gsharedvt argument on the stack on ios. Fixes #39528.

Merge pull request #2820 from kumpera/license-change-rebased

Change license and publish xamarin mono extensions

Update COPYING.LIB

[utils] Fix the build.

Merge pull request #2394 from Mailaender/patch-1

Fixed runtime dependency on libgdiplus with developer soname

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

Update trademark

Merge pull request #1 from xamarin/hannakim123-patch-1

Update for CLA

[runtime] Cycle the finalizer thread if there are too many outstanding hazard pointers to free.

We add a callback to the HP so the GC can monitor the queue size and act on it.

The queue size was picked to keep the overhead limited even under high load.

[Profiler] Use the correct function to increment the refcount

Merge pull request #2807 from akoeplinger/gchandle

[corlib] Two small fixes for GCHandle

Merge pull request #2786 from alexanderkyte/leaked_type_in_parse_header

[runtime] Free leaked short-lived MonoType

Improve a safety check when writing data into StatBuffer

The safety check should occur such that if the new value for
StatBuffer::cursor is beyond the bounds of the StatBuffer, the cursor
is not updated.

Comments and clarity in proflog.c

- Add comments on structures
- Rename 'data' and 'data_end' to 'cursor' and 'buf_end' in
  LogBuffer/StatsBuffer as the old names were confusing
- Add new assert when processing samples

Assist on profiler module loading

- Add a MONO_PROFILER_LIB_DIR from which custom profilers are
  dynamically loaded, in case it is not the normal library path
- Modify mono/profiler make check to use MONO_PROFILER_LIB_DIR
  (this fixes a bug where it would sometimes load the wrong profiler)
- Add information about profiler loading to mono_trace

Merge pull request #2799 from BrzVlad/fix-conc-card-clean

[sgen] Fix concurrent card clean

Merge pull request #2808 from lambdageek/dev/monoerror-security-core-clr

[security-core-clr] Use MonoError outarg instead of mono_raise_exception

Merge pull request #2812 from madewokherd/threadpool-ms-rand

[threadpool-ms] Fix incorrect use of mono_rand.

[threadpool-ms] Fix incorrect use of mono_rand.

This takes a pointer to an RNG handle, not the handle itself.

Merge pull request #2698 from esdrubal/iosxmlarray

[System.Runtime.Serialization] Static writer fix.

Merge pull request #2763 from esdrubal/mono-symbolicate-standalone2

Mono-symbolicate standalone

Merge pull request #2787 from esdrubal/endpointaddress10

[System.ServiceModel] Fixes reflection call to undefined method

Merge pull request #2781 from alexanderkyte/inflated_method_header_leak

[runtime] Fix leaking of inflated method headers

Update CONTRIBUTING.md

[sgen] Don't pump the hazard free queue from sgen, the finalizer thread does it now.

[utils] Replace usage of mono_thread_hazardous_free_or_queue and remove it.

mono_thread_hazardous_free_or_queue has a fundamentally broken design.

It allows arbitrary free code to run in the context of its caller.

The sync/async split on where it's called is not enough to know whether
we can run free'ing code or not.

Since in sync context we called free functions that could take locks,
it happened that those locks conflicted with the ones already taken.

In particular, mono_jit_info_table_free did take a domain lock and
quite a few of the sync context calls would hold locks that must
not be held when taking a domain lock.

This, is practice, means that we'd need to partition the free calls
into 3 groups: async context, reentrant context (no runtime locks held)
and sync context (maybe some locks held).

There was no case where reentrant context would be usable meaning,
in practice, that all calls happens in what effectively is async context
where free functions can't be called.

The new design is a lot more straightforward:

- No implicit free queue pumping
- A pair of free functions with well defined behavior.
mono_thread_hazardous_try_free - to be used where the caller expects the free function to be called
mono_thread_hazardous_queue_free - to be used where the caller don't expect the free function to be called [1]
- Explicit pumping on places that known to be ok
Thread detach
Finalizer thread

[1] This might sound like a weird condition, but a lot of lock-free code
have compensation logic that trigger free'ing during lookups.

[security-core-clr] Add MonoError arg to
mono_security_core_clr_ensure_delegate_creation

[security-core-clr] Add MonoError arg to mono_security_core_clr_ensure_reflection_access_method

[security-core-clr] Add MonoError to mono_security_core_clr_ensure_reflection_access_field

Merge pull request #1718 from madewokherd/sgenthreadcleanup

[sgen] Clean up thread pool on shutdown.

Keeping threads around can cause processes to keep running when they shouldn't, particularly on Windows when the entry point returns.

(The reason this is important for me is that Wine provides _CorExeMain, which is an entry point that does return, unlike normal compiled C programs which appear to call exit() after main() returns. A Windows process doesn't exit until ALL threads have exited, so a thread that never exits means a hung process.)

It doesn't seem like we have other GC-specific cleanup code, so I don't know if this is a good approach. Feedback on that question would be appreciated.