Without proper alignment, this may lead to reference types
being stored at non-pointer aligned offsets. Among other
issues this may lead to the GC not scanning those pointers
properly.

only build 32bit osx on build server. Catalina doesn't support building 32bit so we don't want to do this by default anymore.

* Generalize commit 0c6932a9 to support LDARG{0|1|2|3}, LDLOC{0|1|2|3}, LDARGS, LDLOCS, LDARG and LDLOC instead of LDLOC and LDLOCS. Improves generated code similar to issue #60945

source: https://github.com/mono/mono/pull/12595

Re-adding whitespace to reduce diff noise and make future cherrypicks easier.

* Validate the address that came from IDE using PointerValue. The IDE can send an invalid address and it was crashing mono.

Fixes #18191
Fixes #15612
Co-authored-by: NAleksey Kliger (λgeek) <akliger@gmail.com>

Wrap create_file_to_check_memory_address in #ifndef _MSC_VER check as it's only used in that scope.

The fix for 1256569 broke a test. Reverting most of that change and breaking the CreateLocal -> WinRTFallback -> CreateLocal loop by calling GetLocalTimeZoneInfoWinRTFallback instead of accessing Local from within FindSystemTimeZoneByIdWinRTFallback fixes both issues.

Need to make sure we don't duplicate the timezone and create a new local when we already have one.

Fixing a hang that would occur when there is incorrectly set time zone data in the windows registry. (case 1256569)

[corlib] Use Environment.Platform to access the platform, rather than probing the file system (#6535)

Alternatve patch to: #6533

* mono_custom_attrs_construct_by_type allows unity to have a chance at handling the error if one arises instead of fatally asserting
* mono_unity_error_convert_to_exception allows unity to take the provided MonoError and fetch the MonoException object within to log into the editor as the exception that was thrown.

This change has associated unity changes in order to fix (case 1255935)

Fixing hang that would occur when a Debugger.Break would be triggered while we are already processing a breakpoint. (case 1254123)

Adding test for debugger hang fix to case 1254123

Added a new property to Tests class which breaks this test.

Emitting error 100 times is plenty.

This change applies a similar fix for exFAT partitions as was applied
for FAT32 partitions earlier. For exFAT partitions, the invalid inode
value seems to be 1 though.

Add System.Collections.Generic include to objects.cs

* Removing some asserts and returning err_invalid_argument with an error message when it's possible.

* if we don't find method get_ObjectIdForDebugger we try to find the property Task to continue async debug.

Cherry-picked by Alex Thibodeau with some moderate changes

* When we try to call a method to get the async_id to do an async debug and we are trying to do this in a generic method like this:

async Task<T> ExecuteAsync_Broken<T>()
 {
            await Task.Delay(2);
            return default;
  }

We need to inflate the generic type before call the method or we will get the error:  Could not execute the method because the containing type 'System.Runtime.CompilerServices.AsyncTaskMethodBuilder1[T_REF]’, is not fully instantiated.

Fixes #17549
Fixes #17569

Cherry-picked by Alex Thibodeau -- some light massaging required

* [debugger] Fixing two crashes while debugging an Android app.

-> Doing stepping into in VSM in some situation the frame saved in TLS is not synchronised with what is really been executed in the main thread. This makes the debugger-agent crashes because it tries to get variable info in some memory that is not available anymore.
	-> To fix it I forced the update of stack when CMD_THREAD_GET_FRAME_INFO is called.

-> Doing step over in Visual Studio for Windows, if you have the threads debugger window enabled, VSW calls frame_commands for each thread that is showed, and if the thread is not really_suspended it tries to get variable info from a memory that is not available anymore because the thread is not suspended yet.
	-> To fix it I don't send variable info of a frame if the thread is not really_suspended and doesn't have an async_state valid.

Cherry-picked with some light massaging by Alex Thibodeau (case 1249172)

Branch name updates for 2019.4

Same method that ldloc.s uses, which incorporates the byref test.

When we have the following sequence:

    ldloc n
    ldfld valuetype [Unity.Mathematics]Unity.Mathematics.int2 Foo::bar

and local n is a reference to value, when walking the instructions in
mono_method_to_ir, we generally try to avoid loading a whole value
type just to load one of the fields.  I believe this is an
optimization.

The test here is not quite complete, though, as we have ref valuetypes
where the object stored at the location is actually an address, in
which case we still need to treat it as we would a normal reference.

This optimization isn't present in the ldloc.n coded forms and is
written in a slightly more robust way in ldloc.s, so no changes are
necessary there.

As an alternative to this commit, we might adopt the ldloc.s test for
ldloc as well, or merge in
https://github.com/mono/mono/commit/29428d951637ff85b593ea5c9cc5d5236579906d/mono/mini/method-to-ir.c
from master which encapsulates much the same intent.

This brings us in line with GetDiskFreeSpaceExW on Windows as well as .NET Core.

Attempting to guard against MONO_HANDLE_IS_NULL performing a null deref while checking for null. Sourced from: https://github.com/mono/mono/pull/9188 blindfix for case 1232819

sets.

Making associated change to type_in_image to also check the constrained type for a match. Re-adding asserts now they they no longer trigger.

updating to K&R coding convention

Fixes https://github.com/mono/mono/issues/18127.

- Changed the behavior on debugger-agent, if we can't parse the new behavior is to return invalid_argument and not assert and stop debugging
- Changed the mono_domain_set_fast before return from assembly_commands.
- Add error message when return INVALID_ARGUMENT

Fixes #19146

Fixes #8915

This change modifies the `ConcurrentBag` implementation from corefx.
Since we cannot update the corefx submodule, make a copy of the
ConcurrentBag.cs file, fix the issue, and point the build at this copy.

The change is in the `TrySteal` method. It makes calls on the
`CDSCollectionETWBCLProvider`, which is removed by the manged linker
by default. Those calls should be wrapped in a
`CDSCollectionETWBCLProvider.Log.IsEnabled()` if block, so the linker
can understand to not make the calls.

There was a race where a domain was being unloaded while debugger would access it. A domain was only removed from the 'appdomains_list' as a very last step. The domain was already invalid to access at this point (locks freed for example).

Worse, images would be unloaded if only referenced by that domain. All places the debugger iterates domains hold the loader lock. The loader lock is acquired by the domain unloading process, so as long as a domain is not unloading when we access it inside of the loader lock we are safe.

Manually applied cherry-pick of https://github.com/mono/mono/pull/8428

Unity: Avoid allocation in Enum.HasFlags (case 1211643)

* [jit] Decompose some CEE_BOX opcodes later to allow more optimizations.

Optimize a code sequence emitted for Enum.HasFlag () by newer csc versions.
Also mark the temporary bblocks used by decompose_vtypes () as out-of-line if
the bblock under processing is out-of-line. Mark the domainvar as volatile to avoid
optimizing it away since references to it can now be generated later from the
decomposition of OP_BOX.

* [jit] Check that the enum types are the same.

* [jit] Fix support for generic enums.

* [jit] Disable the optimization with 64 bit enums on 32 bit platforms.