Added MONO_API macro to annotate and control visibility of public (exported) APIs.

This is especially useful for Windows since this way there is no need to maintain a separate .def file with exports which is usually out-of-sync with the latest revisions. This could also be used to control visibility with GCC/Clang so there would be no need for MONO_INTERNAL (could be removed while changing the default visibility to hidden).
Add TimeZoneInfo Serialization

Add serialization for the TimeZoneInfo, TimeZoneInfo.AdjustmentRule and TimeZoneInfo.TransitionTime class. It is compatible with the serialization in .Net for cross serialization/deserialization from Mono to .Net and vice versa.

The code in this commit is released under the terms of the MIT/X11 license.
There was a long discussion on a mailing list about the async-socket problem
in mono. We have previously submitted a patch fixing the problem, however it
was later reverted back as causing deadlocks in some cases.

This patch is very close to the original one, but it takes into account how
tpool-thread operates and avoids deadlocks in this code. (Unfortunately, it
probably makes the code a little less readable, but it works).

So, this patch aims to fix several races in the mono code. These problems are
not relevant for a lot of applications as they can appear only if both read
and write operations are active on the socket. (I.e. RPC style communications
do not trigger the problem).

So, there are two major problems with existing mono code:

a) threadpool.c :: socket_io_add

LeaveCriticalSection (&data->io_lock);
data->modify (data->event_data, fd, state->operation, ievt, is_new);

the problem is that data modify receives ievt and is_new arguments which
may be already outdated due to the concurrent operation on the same socket
(read vs. write).

(If you look at the other part of the operation in
tpool_epoll.c :: tp_epoll_wait updates the epoll settigs under the lock.)

b) The epoll implementation uses the following code to change the epoll
settings in the data->modify handler.

if (epoll_ctl (data->epollfd, epoll_op, fd, &evt) == -1) {
  int err = errno;
  if (epoll_op == EPOLL_CTL_ADD && err == EEXIST) {
    epoll_op = EPOLL_CTL_MOD;
    if (epoll_ctl (data->epollfd, epoll_op, fd, &evt) == -1) {
      g_message ("epoll_ctl(MOD): %d %s", err, g_strerror (err));
    }
  }
}

Here we have the same problem. If concurrent operation updates epoll between
first epoll_ctl and the second epoll_ctl the second will override concurrent
update.

These problems result in missing callbacks on async socket send or receive
completion

The original idea was as simple as just move the data->modify under the lock.
(NOTE: both internal associated list and epoll are updated under the lock in
case of data->wait (see tp_epoll_wait).

As i already noted it causes a problem for tpool_poll.c implementation as it
uses different approach than epoll/kqueue.

This patch still invokes data->modify under the lock, but allow implementation
to release lock at the point where it is appropriate for the given
implementation.

The tpool-poll.c releases lock immediately and thus its behavior remains
unchanged (and it still has a problem of missing send/receive callbacks)

The tpool-epoll/kqueue implementations update their internal structures and
corresponding OS level structures under the locks (as _wait does). This change
makes them reliable in simultaneous socket read/write scenarios.

The following code demonstrates the problem. See readme inside.

https://github.com/ysw/mono-socket-problem/tree/master/SocketTest

NOTE: you need at least 4 coresto reliably reproduce the problem.

It is quite hard to reproduce on OSX, but it is easy reproducible in LINUX.

This commit is licensed under MIT/X11.
Check promoted value type binary equality operations against null too. Fixes #13497
Fix up memory barriers on Windows.

1. The _ReadWriteBarrier intrinsic and friends do not actually issue
   a CPU fence; they are purely for inhibiting the compiler in moving
   loads and stores across the call. So when compiling with MSVC, we
   also need to call MemoryBarrier from Windows.h to issue a fence.
   Note that _ReadWriteBarrier is *not* implied by MemoryBarrier; both
   are *really* needed.
2. On Cygwin, we only support GCC 3.x, so resort to inline assembly to
   issue memory barriers. I would have liked to avoid this, but since
   GCC 3.x doesn't provide __sync_synchronize and we aren't likely to
   upgrade to 4.x anytime soon, this is the workaround for now.
Mark inline assembly in mono-hwcap-s390x.c volatile.
Fix a warning in appdomain.c introduced by 76e8c8ba0f5dad4c154b9ab6dd969ef2eb0bec79.
Fix a C# compiler error in the runtime test suite.
Add a mono_binary_search () function.

This is a replacement for bsearch () because some platforms
have bogus asserts in their implementations.
Comment update
Lift result of enum substraction when operation is lifted due to non-nullable enum type. Fixes #13454
Remove CultureInfo.CurrentCulture dependency from ordinal based string::EndsWith. Fixes #13509
Revert the use of mono_binary_search () in support/supportw.c.

This code can't depend on mono/utils and doesn't need the 'fixed'
implementation of bsearch () anyway since keys are never null.
Consistent use of ch to avoid array indexing more than once.

Replace the couple places where the string character array was being indexed twice in the same block instead of the character being cached locally. Cleanup formatting of the switch statements to follow conventions.
MIT licence
Add more extensive logging to sdb.
Merge pull request #714 from IDisposable/patch-2

Consistent use of ch to avoid array indexing more than once.
Less cascading errors
Add clone for error expression. Fixes #13443
Don't hide internal error exception when reported cannot show it.
Fix an assert in constrained_gsharedvt_call_setup (), mono_class_interface_offset () returns a -1 on failure, not 0.