* inotify lib in FreeBSD is in /usr/local
* libinotify check only FreeBSD

Add a monotouch Mono.Security source file.

Simple Automake concatenation is not enough to do all the evil things.

* autogen.sh: Automake does support adding files to the list of program
sources using += but has no -= to remove them. This means that it's
not possible to replace a source file at all.

Given that, the only option is to patch automake. Call an external
script that apply the whole patch queue instead of doing it there.

Kill this failed attemp at automake configuration extension.

Add 6 sgen configurations with ssb to our test suite.

Now this somehow needed fix, resulted in invalid two-lines-joined-into-one-line output...

Match the existing name for Aes implementation for source/binary compatibility

Adjust System.Core and Mono.Security builds to use MonoTouch's CommonCrypto source files

Merge pull request #522 from kosumosu/master

Fix for bug #2907 XML "choice" not correclty processed during deserialization

Bump ikvm module

Don't use IteratorStateMachineAttribute it makes us csc incompatible

Import caller attributes from referenced assemblies. Fixes #8829

[monkeydoc] Sanitize namespace/path names

[sgen] Try to fix Win32 build.

Fixed Choice ordered read bug #2907

[monkeydoc] Optimize Lucene index creation in ecma-provider by avoiding allocation and generic string matching

[monkeydoc] Add back Lucene search creation for ecma-provider, switching from manually generated XPath to XLinq.

[monkeydoc] Correctly compute internal id

[monkeydoc] Correctly append kind caption to types

[monkeydoc] Set things right

[monkeydoc] Use HelpSource's name to compute the cache key

[doc] Disable mono-tracing as an documented API in TOC as it's not generated anymore.

Revert "Merge pull request #495 from nicolas-raoul/fix-for-issue2907-with-no-formatting-changes"

This reverts commit 8bb9b4409d3f73fdf5ec2afc3b9add6bd33f712f, reversing
changes made to a5dd9d6910896c4d38e1b7d956f1124ab744bc67.

Fix reactive.pc file name in rpm spec.

Automake can't handle missing conditional includes. Shell script our way out.

* autogen.sh: The extension module conditional include can't be done from automake
given this wonderful piece of engineering can't handle missing conditional includes
in any sane way. So what we do is to include them at autogen.sh time.

* Makefile.am.in: This puppy now needs to be pre-processed before all the automake
shinning glory kicks in.

[sgen] Fix SGen tests.

Concurrent sweep is gone, and concurrent M&S is in.

[build] Update Lucene.net submodule to use mono org URL

oops, forgot to bring reactive.pc back after some attempts to fix master build.

Merge pull request #519 from Youscribe/execution_context_call

add LogicalCallContext to ExecutionContext

Merge pull request #521 from DavidS/stub-ServiceInstaller-4-0

ServiceInstaller: add DelayedAutoStart property for NET_4_0

fix build so far.

Add Reactive Extensions as installed libs, take 2 (with fixed rpmspec this time).

ServiceInstaller: add DelayedAutoStart property for NET_4_0

Introduce hooks for parallel build scripts.

* configure.in: Add new configure option that allows a parallel set of
build scripts to contribute to the current one.

* mono/mini/Makefile.am: Include the parallel build scripts when generating
Makefiles.

* mcs/build/gensources.sh:
* mcs/build/library.make: Probe for parallel source lists when building the
class libs.

Introduce support for unlimited trampolines.

With this new code there is no longer an AOT compiler limit on the number of
trampolines, as they are allocated at runtime as necessary on iOS systems.
We use iOS's ability to remap a page to a different address in memory
and we replicate the trampolines we generate in the binary file to a
location in memory near a writable page where the trampolines can find the
specific runtime data needed (basically building writable constant pools).
On a big app like bcltests, this saves more than 900KB of binary size.
There is still the option to use the old code, by passing the "nopagetrampolines"
option tp the AOT compiler (the new code is the default).

Simplify a bit FULL_AOT_RUNTIME build wrt use of CommonCrypto. Ref: assistly #9858

fix code according to mono coding guidelines

fix code according to mono coding guidelines

[sgen] Build fix.

[monodoc] Look for docs in LocalApplicationData

Problem: At present, the MonoTouch installer merges MonoTouch
documentation "stubs" with the locally installed iOS documentation,
and installs them into
/Library/Frameworks/Mono.framework/External/monodoc. Since this
directory isn't world writable, you need to be root to do it.

Previously this wasn't a major problem ("just" run the updater as
root), but Apple is now suggesting the use of a setuid binary to do
this instead of privilege escalation:

http://blog.neteril.org/blog/2012/12/06/a-better-monomac-privilege-elevation/

The problem is that setuid binaries are notoriously difficult to write
properly, and have a large number of ways to be exploited. This is bad.

To avoid this, we instead want to stick the merged documentation into
the per-user directory, which means the updater does NOT need to run
as root, we don't need to write the documentation to a protected
directory, and the security concerns are significantly saner.

This in turn means that monodoc.dll needs to be able to look for docs
in a per-user directory, thus this patch:

Update monodoc.dll to look for documentation in the directory:

Path.Combine (
Environment.GetFolderPath (Environment.SpecialFolder.LocalApplicationData),
"monodoc")

(On OS X/Unix, this is ~/.local/share/monodoc.)

This is a per-user directory, writable by the user.

[sgen] Mention marksweep-conc in the man page.

[sgen] Debugging code to check gray queue section's states.

[sgen] Just pass one struct around, instead of scan_func, copy_func and queue.

[sgen] Use SGEN_ATOMIC_ADD instead of doing it by hand.

[sgen] Define all dummy DTrace macros.

[sgen] A few assertions.

[sgen] Start the workers before pinning when concurrent.

[sgen] Disable redirection to distribute queue after workers have stopped.

[sgen] Fix weak tracking links in concurrent mark.

This was broken because nursery objects were not marked pinned
at the time references were checked, so they were considered dead
and the links were nulled.

We solve this by not unpinning them in the finishing nursery collection
but instead leaving them pinned during the finish-up of the major
collection and unpinning them afterwards.

Make weak links initialized to NULL before calling mono_gc_weak_link_add().

This has no effect, but the weak link DTrace probes don't get uninitialized
pointers anymore.

[sgen] DTrace probes for finalisers and weak links.

[sgen] Remove workers_gc_thread_data.

It's not used anymore.

[sgen] Number of major objects marked in concurrent DTrace probes.

Can be enabled/disabled via #define in sgen-conf.h.  Disabled by default
because it's a small performance hit.

[sgen] Remove debugging printfs.

[sgen] Handle all blocks without mod union tables, not just the small object ones.

[sgen] Handle major object remembers happening outside of nursery collections.

[sgen] Option to disable lazy sweep in MONO_GC_PARAMS.

[sgen] Don't try to wake up workers before they've been started.

We enqueue gray objects before starting the workers, so queue section redirection
can also happen before.  Don't crash with an assertion.

[sgen] Remove stupid old concurrent sweep.

[sgen] Sweep blocks in cardtable scans only if there are marked cards in the block.

[sgen] Don't try to wait for workers unless we're concurrent and/or parallel.

[sgen] More information in sweep and world restart DTrace probes.

Pass to the sweep probes whether a full sweep (including memset and resetting
mark bitmaps) was performed.

Pass to the world restart probes the oldest generation collected during
the pause.

[sgen] Fix locking of the worker distribute gray queue.

The worker distribute gray queue is written to by the main GC thread
and read from by the worker thread(s) for work distribution.  Locking it is
therefore necessary, but we weren't doing it properly.

Previously I implemented optional locking for gray queues, but that's a
bad idea because it makes the enqueue fast path slower.  Now gray queues
are back to non-locking, but we have a new queue type, the section gray
queue, which is only accessible on a gray queue section granularity, not
on an individual object granularity, like regular gray queues.  Performance
there is not as critical, so locking is no problem.

[sgen] Remove gray queue balance.

Old, unmaintained debugging stuff.

[sgen] DTrace probes for sweep begin/end and concurrent start/finish begin/end.

[sgen] Workers dequeue from the distribute gray queue directly.

Previously we manually fed the workers, only restarting the world
when the distribute gray queue was empty, which neglected most of the
benefit of concurrent collection.  Now we use locking for the queue and
let workers drain it while the world runs again.

If the locking turns out to be a bottleneck we could implement a lock-free
queue.

[sgen] Always allocate objects with a vtable.

[sgen] DTrace probes for world stop/restart.

[sgen] Only scan marked objects when processing the mod union card table.

[sgen] Make nursery-is-clean check a MONO_GC_DEBUG option.

[sgen] Debugging checks on gray object enqueues.

Have an optional (compile-time #define) hook in gray object queues to
check references whenever they are enqueued.  Currently we only check
that we never enqueue nursery pointers in the concurrent collector.

[sgen] Never enqueue nursery pointers for the concurrent collector.

The concurrent collector must never touch the nursery because it can change
during nursery collections.  During the initial scan we process all pinned objects
in the nursery.  This must be done non-concurrently.

[sgen] Major collection concurrent with nursery collections.

[sgen] Separate binary protocol entries for collection begin and end.

[sgen] Objects promoted during concurrent collections must be marked, too.

[sgen] Clear nursery fragments before whole heap check.

[sgen] Enqueue objects allocated during minor collections for concurrent.

[sgen] Pass scan function to sgen_drain_gray_stack().

[sgen] Handle forwarded objects better in describe_ptr().

[sgen] Do concurrent collection concurrently.

Finish before the next collection.

[sgen] Allocate job data dynamically.

[sgen] Scan cardtable mod union when finishing up major collection.

[sgen] Do another copy/mark pass when finishing up concurrent collection.

[sgen] Assert that concurrent mark never pins major objects.

[sgen] Factor out major copying and marking from roots, waiting for workers.

[sgen] Don't check the value for nursery in the concurrent wbarrier.

[sgen] Mod-union card tables.

[sgen] Don't pin when doing concurrent collections.

The mutator can't handle the pin bit, and the concurrent collector
doesn't move objects out of the nursery, so pinning is neither
required nor allowed.

[sgen] Reset pinning early in concurrent collector.

The concurrent collector doesn't do anything with pinning data, and
pinning must be reset for intervening minor collections.

[sgen] Separate function for finishing major collections.

[sgen] Only allow the card table wbarrier for concurrent collections.

[sgen] Some nursery stuff isn't necessary for concurrent mark.

Concurrent mark requires that it's preceded by a nursery collection,
so we don't need to do some stuff again.

[sgen] Separate mark for concurrent collector.  Not concurrent yet.

[sgen] Concurrent flag for major collectors.

[sgen] Mark/pin large objects in the LOS header, not the vtable word.

This is necessary for the concurrent collector because we are not
allowed to change the vtable pointer while the mutator is running.

[sgen] Split major collection into startup and work.

Startup is everything that's done to feed the workers.  The rest is
waiting for the workers to finish, and sweep/cleanup.

[sgen] Tiny code cleanup.

[sgen] Remove superfluous fields from LOSObject.

[sgen] Mark unused gray queue as invalid.

For parallel collections we don't use the main thread's gray queue, so
assert in case there's something enqueued.

Properly (?) fix TimeZoneInfo.cs build.

I'm just taking a wild guess that this is the proper fix.  Please review.