Use PathString type to allocate large path strings on linux scenario.
Respond to PR feedback. Fix test failures in mscoree.

Commit migrated from https://github.com/dotnet/coreclr/commit/965e5d6480ebbff3d021665f95a37cb94eb9d56a

Use SString type for path allocations in binder.

Commit migrated from https://github.com/dotnet/coreclr/commit/b8282e0b7359e1abbcfdf4574621118b4f61d377

Merge pull request dotnet/coreclr#1584 from DasAllFolks/patch-1

Unbreak "breaking changes" link

Commit migrated from https://github.com/dotnet/coreclr/commit/8811dcdddbbde43e8286bfe29765fe4bd3ae328d

Unbreak "breaking changes" link

Previous link produced a 404 error.

Commit migrated from https://github.com/dotnet/coreclr/commit/17fb74a8dbf90c335987a3bb28ebc53708ead6f9

Merge pull request dotnet/coreclr#1581 from dotnet-bot/from-tfs

Merge changes from TFS

Commit migrated from https://github.com/dotnet/coreclr/commit/5f359dc2c22fc2d30f346911814d7ed91f40d2b1

Merge pull request dotnet/coreclr#1574 from kouvel/FixPalTests

Fix some frequently failing PAL tests

Commit migrated from https://github.com/dotnet/coreclr/commit/8c86f7fdfe7b1f48a06f4172a35a69f5a461bccd

Fix some frequently failing PAL tests

Some PAL tests are frequently failing in the CI. The specified output folder is currently used as the working folder for all PAL tests. The CI machine happened to have the output folder on a mount mounted as fuseblk instead of ext4. We don't know why this is happening. For the moment, I'm fixing the test runner to work around this issue.

Changes:
- Use /tmp/PalTestOutput/default as the output folder by default
- If a specific folder is specified for the output, use a unique folder inside /tmp/PalTestOutput for output files, and copy them to the specified folder at the end. A unique folder is used to support parallel runs on the same machine in this mode.
- Run each test in its own folder. Many PAL tests don't clean up after themselves, and create/use the same file/folder names in the current folder.
- Add a few more checks to some tests to hopefully provide more information upon the next failure
- Fix GetFileAttributes tests, which were crashing upon some failures due to mismatched number of placeholders and arguments to vprintf

Fixes dotnet/coreclr#1561

Commit migrated from https://github.com/dotnet/coreclr/commit/e0c013e2af50bace4004e856cba67fcbec01fc00

Port the DateTime parser fix with Serbia cultures

Serbia has '.' at the end of the date and time parts. (like 'd.M.yyyy.'). while '.' is marked as date and time separator in same time. this confuse the parser and make it fail
to parse date/time string formatted with the Serbia culture.

[tfs-changeset: 1526268]

Commit migrated from https://github.com/dotnet/coreclr/commit/596f0cdafe9f8f2ee2a16419e6203c8e1a8e46d4

Merge pull request dotnet/coreclr#1460 from bbowyersmyth/StringJoin

String.Join optimization for single item lists

Commit migrated from https://github.com/dotnet/coreclr/commit/d176041723f366c35fd71ee4b176253fefddfee1

Merge pull request dotnet/coreclr#1578 from dotnet-bot/from-tfs

Merge changes from TFS

Commit migrated from https://github.com/dotnet/coreclr/commit/5c3324b982039efdf9f1c1cc9a401a5c7fd3770b

Fix build break on arm

[tfs-changeset: 1526208]

Commit migrated from https://github.com/dotnet/coreclr/commit/586006e4255a7db70601c556e9ab95e50771a7a3

Merge pull request dotnet/coreclr#1575 from benpye/arm-unwind-regression

Fix ARM unwind regression

Commit migrated from https://github.com/dotnet/coreclr/commit/097e72ad43195c4c4c8a6332ff5e1fc3134751d0

Merge pull request dotnet/coreclr#1568 from dotnet-bot/from-tfs

Merge changes from TFS

Commit migrated from https://github.com/dotnet/coreclr/commit/de5f5f9c1d308f523d318ad7758f3aa3f348d3c1

Fix ARM build regression

Commit migrated from https://github.com/dotnet/coreclr/commit/c893bf0699c81d7ea9ca9d37543eb5339d64d116

Merge pull request dotnet/coreclr#1559 from eerhardt/Fix2788

Time Zone transitions are 1 tick off on Linux

Commit migrated from https://github.com/dotnet/coreclr/commit/059b6592a9bc1390a982f34a4a693a1159d7bd97

Merge pull request dotnet/coreclr#1560 from Priya91/longpath-test

Replace MAX_PATH with new defines in rest of coreclr.

Commit migrated from https://github.com/dotnet/coreclr/commit/8ff2389204d7c41b17eff0e9536267aea8d6496f

Fix for GH issue 410 - https://github.com/dotnet/coreclr/issues/410

Whenever a managed exception is thrown, the details about the thrown exception are also saved off the managed thread object (as LastThrownObject). The VM also has an exception tracker that tracks its dispatch across the managed frames and incase of nested exceptions, the trackers are collapsed correctly, when the nested exception is handled, and last thrown object is updated correctly. The VM works on the premise that the LastThrownObject is updated correctly.

Incase of this bug, a method (M1)is invoked via Reflection and has an exception E1. During exception dispatch for E1, an IL filter is invoked that, in turn, has an exception (E2) that remains unhandled. While this is swallowed by the VM (as expected), the LastThrownObject is not updated to reflect the active exception to be E1. Thus, when the dispatch for original exception E1 completes and no managed handler is found, the exception is caught by Reflection subsystem that extracts the thrown exception using the GET_THROWABLE macro that uses the LastThrownObject to determine the thrown exception. Since the LTO was not updated, it still reflects E2.

The fix is to update the managed exception state, if the filter has an unhandled exception, similar to how we do when a managed catch block successfully handles the exception. I have refactored the code to make the semantic cleaner.

[tfs-changeset: 1525835]

Commit migrated from https://github.com/dotnet/coreclr/commit/14de7d30063c2955523c1ff2ccb48e339977742b

Time Zone transitions are 1 tick off on Linux

When we build the AdjustmentRules up, we set the StartDate to be the Transition Time that comes from the tzfile, and we set the EndDate to the be (the next Transition Time - 1 tick). That way the next AdjustmentRule goes into effect at the exact transition time. The issue is that the code in CheckIsDst uses a less than operator when comparing the endTime, but for these rules it should be less than or equal to.

Fix https://github.com/dotnet/corefx/issues/2788.

Commit migrated from https://github.com/dotnet/coreclr/commit/5841002dca5c1138e4c51ccf6ab16bf9c6e177e6

Merge pull request dotnet/coreclr#1564 from dotnet-bot/from-tfs

Merge changes from TFS

Commit migrated from https://github.com/dotnet/coreclr/commit/8cad40bbcf4c404c518c1f202a0f93cf71c866c6

Merge pull request dotnet/coreclr#1562 from cshung/EventCounterWork

Port bug fixes and add hooks for EventCounter work

Commit migrated from https://github.com/dotnet/coreclr/commit/b66746c9132c157b807e3387147c4337b8c6cae0

Merge pull request dotnet/coreclr#1553 from paulnice/patch-1

Fix runtime versions in the Console example

Commit migrated from https://github.com/dotnet/coreclr/commit/c27a149e3e0b15e5449ab5a0b6c87752dae2ee4e

Merge pull request dotnet/coreclr#1557 from ravimeda/master

Update Build CoreCLR Instructions on Mac OS X.

Commit migrated from https://github.com/dotnet/coreclr/commit/f8c2d7a18e90834f29107fa6cd1a3fc3d80da77c

Port bug fixes and add hooks for EventCounter work

Commit migrated from https://github.com/dotnet/coreclr/commit/cb67da60a9c462b620afc1e8b7571228cbf46ac3

Merge pull request dotnet/coreclr#1554 from kouvel/WaitAllCheckForDuplicates

Check for duplicate handles in PAL's implementation of a wait-all ope…

Commit migrated from https://github.com/dotnet/coreclr/commit/830570c135db0bd917c9e4239314fd6f976e21bb

Merge pull request dotnet/coreclr#1538 from Djuffin/get_context2

Make DBI/SOS stackwalk work when thread is running native code

Commit migrated from https://github.com/dotnet/coreclr/commit/15875d3a98e496191f221ebb003ab53ec77cfae9

Merge pull request dotnet/coreclr#1555 from richlander/roadmap

Add link to .NET Core Roadmap

Commit migrated from https://github.com/dotnet/coreclr/commit/cdb64362a7b3754738b11f0623daa0a3217d570a

Update Build CoreCLR Instructions on Mac OS X.

Rebuild option is not handled in build.sh.  Hence removing the sentence
that suggests using a rebuild option that will delete previously built
assemblies.

Commit migrated from https://github.com/dotnet/coreclr/commit/a0864bcf599287d268c765d6558a7718d365561e

Use out-of-proc libunwind to unwind native stack from DAC

Implementation of PAL_VirtualUnwindOutOfProc that uses ptrace libunwind
to be able to unwind native stack in debugee. This allows to get valid managed
stack for threads that passed HelperMethodFrames.

Commit migrated from https://github.com/dotnet/coreclr/commit/d0f71d0b22e9012263e4a078d24738c75e384a90

Use Frame list context when GetThreadContext is unavailable

When DAC tries to obtain thread context for debugee thread on the system without working GetThreadContext, it uses filter context
and if it is NULL, it goes through thread Frame list looking for a Frame that can provide meaningful CONTEXT to start the stackwalk.
Filter context can be NULL if the thread is currently running native code, or manage exception just has been thrown (first chance).
Before this change DBI stackwalker would fail to provide stack trace in such cases.

Commit migrated from https://github.com/dotnet/coreclr/commit/eb3260e67bc653b56a80fbf0e8a07d78e3a404c1

Merge pull request dotnet/coreclr#1540 from BruceForstall/FixPow1TestForLinux

Fix pow1 test to run on Linux

Commit migrated from https://github.com/dotnet/coreclr/commit/235d807ed6012590241a8e21433a257df7de264a

Merge pull request dotnet/coreclr#1144 from mmitche/real-debug-build

Do not pass /O1 except in release/release with debug info modes

Commit migrated from https://github.com/dotnet/coreclr/commit/2bc5657bd796e78d33aff45c7137b92b821d3a93

Check for duplicate handles in PAL's implementation of a wait-all operation

Commit migrated from https://github.com/dotnet/coreclr/commit/ddf916ca46e913fbe3c8536b2a8c0d951ef1474b

Do not pass /O1 except in release/release with debug info modes

Commit migrated from https://github.com/dotnet/coreclr/commit/fd5bea19761805968c966043fab38aedda23e912

Minor change to SystemV structs declarations in JIT-EE interface

Pull over a couple changes from the work-in-progress git branch.

[tfs-changeset: 1525036]

Commit migrated from https://github.com/dotnet/coreclr/commit/81bd7868b69f99e2e3c8f6486547327461aa8941

Fix build break on ARM.

[tfs-changeset: 1525030]

Commit migrated from https://github.com/dotnet/coreclr/commit/3083f4a15ef307794a34b9a580de9039d0d06c5e

Fix runtime versions

1. Fix the sample output of 'dnvm list' command with the latest one.
2. Fix the 'dnvm use' commands with the current runtime versions.

Commit migrated from https://github.com/dotnet/coreclr/commit/ceabbbc2c6cc129ee09b6159acae71055f99460f

This fixes the case of 64bit (to be in sync with Arm/Arm64) failures when, due to Jit optimizations, the return address of two successive frames are the same, resulting in incorrect current context initialization. As a result, CrawlFrame specific lookup of data (e.g. GenericArgType) are incorrect and fails tests.

I have refactored the code to be common for X64/Arm/Arm64 as much as possible.

X64 EH Selfhost is clean (and so is DDR).

[tfs-changeset: 1524814]

Commit migrated from https://github.com/dotnet/coreclr/commit/565c615fc357e06e328de2ce0b26a58163edeedc

Merge pull request dotnet/coreclr#1547 from jkotas/standalone-gc

Initial port of GC sample to Linux

Commit migrated from https://github.com/dotnet/coreclr/commit/98c63c1612b2635a40d9a719c1505e0ad4bef08a

Merge pull request dotnet/coreclr#1546 from dotnet-bot/from-tfs

Merge changes from TFS

Commit migrated from https://github.com/dotnet/coreclr/commit/8b45ec0f0213f9b85b1f38c606e8d25a68a5bc58

Initial port of GC sample to Linux

- Add CMake build for the GC sample
- Add Unix clone of the GC environment. The Unix GC environment is partially
implemented, enough to make GC sample to compile and run on Linux.

Commit migrated from https://github.com/dotnet/coreclr/commit/eeb7076e3993ca3fea11ee599a272d985eb3d4d4

Fix mscorlib asmmeta and add SecurityCritical attribute to the two new functions in AssemblyExtensions

[tfs-changeset: 1524637]

Commit migrated from https://github.com/dotnet/coreclr/commit/8d7491b0ac6f7569f5a04587e5e0e3165066c5e6

Merge pull request dotnet/coreclr#1543 from mikedn/unboxmsg

Improve the invalid cast message generated by unbox

Commit migrated from https://github.com/dotnet/coreclr/commit/003a8b171a4fcac4907fe03facf4c84246435985

Improve the invalid cast message generated by unbox

Change JIT_Unbox to use COMPlusThrowInvalidCastException instead of
COMPlusThrow(kInvalidCastException). This mirrors the behavior of
the normal cast by including the source and destination types in
the exception message.

Fix dotnet/coreclr#1453

Commit migrated from https://github.com/dotnet/coreclr/commit/6732963050da5881f380ede3ab3f491a64fd04ce

Merge pull request dotnet/coreclr#1544 from jkotas/standalone-gc

GC sample improvements

Commit migrated from https://github.com/dotnet/coreclr/commit/320ee7e64cc6304e7b01948dabbc5e9e26f9bf45

Move sample GC environment to separate directory

Commit migrated from https://github.com/dotnet/coreclr/commit/1d78cb898e00369d6894af174d5727fc6660a211

Use NULL for consistency

Commit migrated from https://github.com/dotnet/coreclr/commit/3691f2a234c0ef361a54a946098ebdfdcf4fc391

Replace unsigned __int64/__int64 with UINT64/INT64

Commit migrated from https://github.com/dotnet/coreclr/commit/b9e4ab6395587064d99820f33b807abe20124dc2

Merge pull request dotnet/coreclr#1539 from BruceForstall/DeleteBadTests

Delete two bad tests

Commit migrated from https://github.com/dotnet/coreclr/commit/58748f0c50e71aed5ed2a3e35feb0a9eb719eaa6

Merge pull request dotnet/coreclr#1542 from jkotas/gcsample

Upgrade GCSample project to VS2015

Commit migrated from https://github.com/dotnet/coreclr/commit/12d294af33553f6f9b93491143733ca78a85aef8

Upgrade GCSample project to VS2015

Commit migrated from https://github.com/dotnet/coreclr/commit/6169f97d41b1de101a884a3035804d893878bf54

Fix pow1 test to run on Linux

This tests queries PROCESSOR_ARCHITECTURE to see if it is running on ARM. This returns a null string on Linux. So, check for null on continue. If necessary, this could be adjusted later if we need to do something special for non-Windows .NET Core on ARM.

Commit migrated from https://github.com/dotnet/coreclr/commit/396373adde3ea53f136ac99f7e9e1936811b3e9c

Delete two bad tests

These tests were deleted from internal runs long ago and should not have been ported.

Commit migrated from https://github.com/dotnet/coreclr/commit/2bb5c8c5cded8f6849bebf0ae5eb0c9e75ac37aa

Merge pull request dotnet/coreclr#1536 from BruceForstall/FixLinuxNullRefCheck

Fix JIT null reference checking for large field accesses on PAL

Commit migrated from https://github.com/dotnet/coreclr/commit/0554a236ffe62e68f09969df4249a22bdf6ddc2c

Merge pull request dotnet/coreclr#1537 from BruceForstall/FixLinuxIntLongDifference

Replace 'long' by 'int' to avoid bug on Linux

Commit migrated from https://github.com/dotnet/coreclr/commit/54913c983114fb451c8c55b3c51290b5512a4e59

Replace 'long' by 'int' to avoid bug on Linux

In GetSignedMagicNumberDivide(), a cast to (unsigned long) was doing a sign extend instead of a zero extend, leading
to an apparent infinite loop with test case b147814_il.exe. This change replaces the cast with (unsigned int), which
matches Windows behavior.

Commit migrated from https://github.com/dotnet/coreclr/commit/81291720abef64f07db0b01162b4ee1bde4ff7f8

Fix JIT null reference checking for large field accesses on PAL platforms

The JIT needs to do explicit null checks for large field accesses if such an
access might exceed the unmapped zero page in the OS. On Windows, that means
fields over 32KB. On PAL platforms, we use 1/2 the OS page size. As far as I
can tell, the reason we use 1/2 the known unmapped page size is for "defense
in depth", in case we get it wrong somehow.

Commit migrated from https://github.com/dotnet/coreclr/commit/26a4e5fd0f5eefc91d1b46e2505290723b01780e

Merge pull request dotnet/coreclr#1523 from dotnet-bot/from-tfs

Merge changes from TFS

Commit migrated from https://github.com/dotnet/coreclr/commit/ff51d9e5384a61d22342aa640deafe62ec5a8754

Merge pull request dotnet/coreclr#1495 from Sridhar-MS/code-coverage

Build Code Coverage instrumented binaries for native binaries in Linux and OSX

Commit migrated from https://github.com/dotnet/coreclr/commit/79880beb8c6d12b385db08ad1120d7edf7812b41

String.Join optimization

Commit migrated from https://github.com/dotnet/coreclr/commit/c81320a28805b098aaee9ea0d0149e7f2dd24a8f

Merge pull request dotnet/coreclr#1533 from janvorli/fix-native-unwind-issue

Fix null reference exception handling in JIT_WriteBarrier

Commit migrated from https://github.com/dotnet/coreclr/commit/fd27971f925051dac191d429c5fdadc61adbd960

Fix null reference exception handling in JIT_WriteBarrier

This change fixes an issue when a null reference exception happens in the first
instruction of the JIT_WriteBarrier. There were two problems.

First problem was that the native unwinder didn't know that it is unwinding a
frame where the PC is an address of a failing instruction instead of the next
address after a call instruction. So it decremented the PC before looking up the
unwind info. Unfortunately, that means that if the hardware exception happens
in the first instruction, the unwind info is not found and the unwinder resorts
to RBP chain unwinding, which effectively skips one managed frame.

The second problem was that the FaultingExceptionFrame we create when handling
the hardware exception had context pointing to the JIT_WriteBarrier. But that
breaks the stack walker. When it arrives at the FaultingExceptionFrame, it
calls its ReturnAddress method and expects to get a managed code address.
However, in this case, it was getting the address of the JIT_WriteBarrier instead
and that made the stack walker to skip to the next explicit frame, effectively
skipping multiple managed frames that it should have reported.

Commit migrated from https://github.com/dotnet/coreclr/commit/af76ec004c3d7c50abe29ddbfd3be37df30e21cb

Merge pull request dotnet/coreclr#1499 from kouvel/TryGetRawMetadata

Add AssemblyExtensions.TryGetRawMetadata to the System.Reflection.Met…

Commit migrated from https://github.com/dotnet/coreclr/commit/f7d9f0b298f7801344172fbaa5ec435be7e7171f

Merge pull request dotnet/coreclr#1522 from kouvel/AssemblyLoadNullVersion

Allow loading assemblies on the TPA list without specifying a version

Commit migrated from https://github.com/dotnet/coreclr/commit/cd2e9f19be91127f448708ab81aca0b25011d981

Respond to PR feedback.

Commit migrated from https://github.com/dotnet/coreclr/commit/3b05c625e21ed968f1966b78956c99326fcc0570

Fix to correctly spill a special putarg_reg when the fixed register assigned to it is getting killed before its GT_CALL.

Essentially in execution order we have the following nodes

     RCX <-- GT_PUTARG_REG(lcl var V07)  here V07 is 'this' object
     R8 <-- GT_PUTARG_REG(GT_AND(GT_LSH,...))
     ControlExpr of call (i.e. call target) is a vtable call and uses 'this' object to get to the right virtual method. Essentially a GT_IND(GT_LEA(V07))
     GT_CALL

While building ref positions for first putarg_reg, it is flagged as "special" and preferenced to its source lcl var V07 if it is the non-last use.   The hope is that if there are further uses of V07 before the kill of fixed reg assigned to V07, they can continue to be in that register.
While allocating a register to a special putarg_reg, lsra checks that a) source lcl var's interval is active and b) register assigned to source lcl var is the same as putarg_reg

Second putarg_reg (to R8) has an operand which needs CL (shift operation) and hence will kill RCX before GT_CALL. As a result, V07 is marked for spilling after its use in special putarg_reg but not first putarg_reg.  Further since next kill of RCX (GT_LSH) is well before the next use of source lcl var (in controlExpr), putarg_reg cannot be marked as isBusyUntilNextKill.  As a result, LSRA would think that RCX is available for allocation after the last use of V07 in controlExpr and hence GT_IND is allocated RCX thereby thrashing 'this' object passed in RCX.  This leads to an AV for the repro case while executing jitted code.

Fix is that while allocating LSRA also needs to check that the next use of special putarg_reg is same as the next kill of the fixed register assigned to it. Since first putarg_reg is not marked as special, kill of RCX by GT_SH would lead to spilling of putarg_reg into a tree temp.

Fix dotnet/coreclr#1475

[tfs-changeset: 1523584]

Commit migrated from https://github.com/dotnet/coreclr/commit/698641c0a7807b7f37143b923f8926c8f90a0f42

Address code coverage builds feedback

- Move the build type check to unix only.
- Remove the global fPIC compiler option and add it as compile flags for libcorguids @ src/inc/CMakeLists.txt
- Use add_compiler_options instead of add_definitions.

Commit migrated from https://github.com/dotnet/coreclr/commit/2d433c12a29a68e8f9d03ed40e55acbfb601556e

Add AssemblyExtensions.TryGetRawMetadata to the System.Reflection.Metadata namespace.

This patch contains has the necessary changes in coreclr and mscorlib. Tests will be added separately, once the new API is
published and can be consumed.

Part of dotnet/corefxdotnet/coreclr#2768

Commit migrated from https://github.com/dotnet/coreclr/commit/2f042a1212137e558fca716dbb92197f7a770e55

Allow loading assemblies on the TPA list without specifying a version

When comparing the bound assembly's version against the requested assembly name, removed the distinction between platform
assemblies and app assemblies when the bound assembly is on the TPA list. A requested version of null behaves equivalently to
a requested version of 0.0.0.0.

Commit migrated from https://github.com/dotnet/coreclr/commit/fda827e5f6c732472b95a3672cc888f28e02a0ec

Merge pull request dotnet/coreclr#1520 from sergey-raevskiy/clarify-comment

Clarify comment

Commit migrated from https://github.com/dotnet/coreclr/commit/b4c53d212ab86bdc1b9b948b22f88a0aea894fab

Clarify comment

Commit migrated from https://github.com/dotnet/coreclr/commit/f7ae389b4272fe7f95c69ca640516068fb044844

Merge pull request dotnet/coreclr#1518 from janvorli/fix-some-printf-formats

Fix printf formatting for ll, I and I32 length modifiers

Commit migrated from https://github.com/dotnet/coreclr/commit/bb260291f7b2dd7744a7ddd950c3b7ae00259611

Reflect PR feedback

Commit migrated from https://github.com/dotnet/coreclr/commit/7c07014c9967063adbc80295856086f214fd1885

Merge pull request dotnet/coreclr#1497 from adityamandaleeka/fix_warnings

Fix the remaining unused variable/label warnings

Commit migrated from https://github.com/dotnet/coreclr/commit/6c29dd0322d3377db1c2ec2ead8bfd173a353f2e

Fix printf formatting for ll, I and I32 length modifiers

These modifiers were not handled at all.

Commit migrated from https://github.com/dotnet/coreclr/commit/f4686f5f908d6e7c33655953395ed51f0bbba4d2

Merge pull request dotnet/coreclr#1516 from janvorli/fix-managed-exception-dispatch-2

Fix missing uses of the INSTALL_MANAGED_EXCEPTION_DISPATCHER

Commit migrated from https://github.com/dotnet/coreclr/commit/9b316806a1cb13c47e622377b9c4cd1989faffb6

Replace MAX_PATH with new defines, rest of coreclr.

Commit migrated from https://github.com/dotnet/coreclr/commit/260f64716ae3bc8fb9ae4708cbb8d4a0a6c48a91

Fix missing uses of the INSTALL_MANAGED_EXCEPTION_DISPATCHER

This fixes issues stemming from my recent changes in managed exception dispatching
where I have missed few places where we need to perform managed exception dispatching
or unhandled exception reporting.

Commit migrated from https://github.com/dotnet/coreclr/commit/731957fdf39aa0afd30e415c97bcdd3c7aeac137

Fix the remaining unused variable/label warnings

Commit migrated from https://github.com/dotnet/coreclr/commit/a650e9afdfabce811db9bed39ccffe5904cc75ee

Change warning to error for platforms not supporting code coverage at this time. This is make sure that the warning does not get accidently swallowed at some point in the future.

Commit migrated from https://github.com/dotnet/coreclr/commit/e75e5007860e2afd356721010a583ce3b4af5fc1

Merge pull request dotnet/coreclr#1515 from janvorli/fix-funceval-personality-routine

Remove FuncEvalHijackPersonalityRoutine for PAL

Commit migrated from https://github.com/dotnet/coreclr/commit/2d2d0a5b512e2832565c448d9b4c6d6c1897f150

Remove FuncEvalHijackPersonalityRoutine for PAL

The personality routine on Windows is responsible for redirecting exception unwinding
to a different context when function evaluation is injected into a managed thread and
there is an exception that escapes the evaluation. However, the FuncEvalHijackRealWorker
catches all exceptions that happen during the function evaluation, so nothing should
escape.
Moreover, if anything escaped, it would go to the original hijacked code which is not
expected.
So I am replacing the personality routine for PAL with UnhandledExceptionHandlerUnix
to guard against unexpected exception escaping.

I am also setting the same personality routine to the ExceptionHijack function. Some
time ago, it was removed completely there as a temporary fix for a problem with limited
max number of personality routines in single executable. I have looked at it
again and I can see that no exception should escape the ExceptionHijackWorker either and
so the same thing as for FuncEvalHijack applies for ExceptionHijack too.

Commit migrated from https://github.com/dotnet/coreclr/commit/b7bcb50634745d5280386fb8b03e204896d54df3

Merge pull request dotnet/coreclr#1496 from janvorli/fix-exception-memleak

Fix memory leak from managed exceptions

Commit migrated from https://github.com/dotnet/coreclr/commit/508454cc76e1bd35c07521ebfc73617c00c5bcb3

Merge pull request dotnet/coreclr#1514 from janvorli/fix-managed-exception-dispatch-way-2

Fix managed exception dispatching

Commit migrated from https://github.com/dotnet/coreclr/commit/f7552e5a5076b63d88886f9d4ec5c781508e307e

Fix managed exception dispatching

The managed exception dispatching is initiated from the UNINSTALL_MANAGED_EXCEPTION_DISPATCHER
macro and it should be used only at the border between managed and native code, when managed
code calls native one. This macro is part of the UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_NO_PROBE
macro. However, it turns out that the UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_NO_PROBE
(or the UNINSTALL_UNWIND_AND_CONTINUE_HANDLER that uses it) is also used at places where
there is no managed / native border. In that case, the managed dispatching results incorrectly
in skipping native frames that would otherwise handle the exception.

The fix removes the INSTALL_MANAGED_EXCEPTION_DISPATCHER / UNINSTALL_MANAGED_EXCEPTION_DISPATCHER
from the INSTALL_UNWIND_AND_CONTINUE_HANDLER_NO_PROBE / UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_NO_PROBE
and puts them to specific places where INSTALL_UNWIND_AND_CONTINUE_HANDLER_NO_PROBE /
UNINSTALL_UNWIND_AND_CONTINUE_HANDLER_NO_PROBE and INSTALL_UNWIND_AND_CONTINUE_HANDLER /
UNINSTALL_UNWIND_AND_CONTINUE_HANDLER are used at the border between managed and native code.

Commit migrated from https://github.com/dotnet/coreclr/commit/468666bc8bd0c58268187cea5749cef63479b30e

Merge pull request dotnet/coreclr#1507 from mikem8361/fixosx

 Fix debugger/debuggee connection on OS X

Commit migrated from https://github.com/dotnet/coreclr/commit/969a31785514ce05777f0894cac1c7b933a4e227

Fix debugger/debuggee connection on OSx.

The reason there were problems connecting on OS X was that the read
on the debugger/debuggee pipe didn't return the full number of bytes
requested on the first read. There are times (depending on the size
of the read request) that multiple reads to be made to get all the
bytes requested. This change adds code to retry the read or write
until all the bytes requested are read or written.

Commit migrated from https://github.com/dotnet/coreclr/commit/101564176e170f639053f9ed8155d962cd8275c5

Merge pull request dotnet/coreclr#1503 from benpye/arm-strike-build-fix

Fix ARM Strike build

Commit migrated from https://github.com/dotnet/coreclr/commit/284f3314bbb2dc70db52887f58ff1faab4373cd2

Merge pull request dotnet/coreclr#1501 from erozenfeld/ReadyToRunThrowHelpers

Add mappings for ReadyToRun helpers used by llilc.

Commit migrated from https://github.com/dotnet/coreclr/commit/bbc0fc2db020796fee2c686e82a7e13af1482f81

Fixes ARM Strike build

Commit migrated from https://github.com/dotnet/coreclr/commit/8848ab12e6659ac5c6ccc57b9c4aa2d1d4ec9d8b

Add mappings for ReadyToRun helpers used by llilc:
READYTORUN_HELPER_ThrowNullRef and READYTORUN_HELPER_ThrowDivZero.

Allow ReadyToRun tests to be run with llilc.

Commit migrated from https://github.com/dotnet/coreclr/commit/0e5fe01c33eb4f008f4d626e5d7ccdb1c1410a18

Fix memory leak from managed exceptions

Handling thrown PAL_SEHException was causing leaks for all exceptions thrown due to
two aspects:
1) PAL_GetStackBase() and PAL_GetStackLimit() were missing calls to pthread_attr_destroy()
2) We were calling the DispatchManagedException from C++ catch handlers and this function
   never returns. So the C++ exception handling never called __cxa_end_catch that is
   responsible for freeing the exception storage allocated by the C++ runtime.
The fix to the 2nd aspect was to store a copy of the exception in the catch handler, let it
complete and then call the DispatchManagedException with the copy. It was also necessary to
slightly modify the unwinding of sequences of native frames since there is now no rethrowable
exception and the StartUnwindingManagedFrames has to throw a new one.
This change has a secondary benefit - the StartUnwindingManagedFrames no longer calls
__cxa_rethrow, but rather a helper C++ function that uses regular "throw" keyword.
That makes the code more portable.

Commit migrated from https://github.com/dotnet/coreclr/commit/88cf961965911b21f26699ac35ad5223e6f4496a

Merge pull request dotnet/coreclr#1491 from janvorli/unix-remove-thread-affinity-and-critical-region

Remove thread affinity and critical region stuff for Unix

Commit migrated from https://github.com/dotnet/coreclr/commit/248e8e447409274392ff284e58dfc2202fa0a15f

Remove thread affinity and critical region stuff for Unix

The WaitHandleNative::CorWaitMultipleNative was calling Thread::BeginThreadAffinityAndCriticalRegion
that results in incrementing the Thread::m_dwCriticalRegionCount. However, there is nothing
that would decrement it on CoreCLR, so if the WaitHandleNative::CorWaitMultipleNative is called,
in debug build we get an assert in Thread::InternalReset.

It turns out that the critical region and thread affinity stuff is not to be used in CoreCLR,
so I have disabled handling of that in CoreCLR for Unix.
The only remainder are the static methods Thread::BeginThreadAffinity and Thread::EndThreadAffinity
which are used in the ThreadAffinityHolder. Conditionally removing the holder usage would be messy,
so I have rather kept those methods and made their bodies empty.

Commit migrated from https://github.com/dotnet/coreclr/commit/0aaf0a793e95fbef99c2c7e7e68fb3e1e91adcff

Build Code Coverage instrumented binaries for native bianries in Linux and OSX.

Add an option in build.sh called 'coverage' to produce gcov-style instrumented builds.
Example usage - ./build.sh debug coverage clean

This will generate the '.gcno' notes files for each object file in the same directory along with the instrumented native binaries. These .gcno files contain some of the coverage data like source line mappings, basic block graphs info etc.

Each time these instrumented binaries are run, a separate .gcda file is created for each object file in the same directory. These .gcda files contain arc transition counts, and some summary information.

Code Coverage reports can be generated from the .gcno and .gcda files using a tool like gcovr or lcov. *But this commit is only for generated the .gcno files while compiling with the 'coverage' option.*

The next steps
 - Add option in run-test.sh to generate code-coverage reports using the instrumented native binaries.
 - Integrate with Jenkins CI to do code-coverage runs.

Commit migrated from https://github.com/dotnet/coreclr/commit/38f82df88a37fa4f47bd1b01b0faad9970b00476

Merge pull request dotnet/coreclr#1484 from gitchomik/master

Documentation - building mscorlib.dll using Mono on Linux

Commit migrated from https://github.com/dotnet/coreclr/commit/b6c0cdc4d52455dbff31cfe621149be348150728

Building mscorlib.dll using Mono on Linux

Some information about building mscorlib.dll without Windows

Update linux-instructions.md

some @ellismg suggestions

Commit migrated from https://github.com/dotnet/coreclr/commit/d1ce284a0824250a32711fa7abf04aff051fb290

Merge pull request dotnet/coreclr#1493 from christos-P/patch-1

minor correction

Commit migrated from https://github.com/dotnet/coreclr/commit/1f609113d5bbf2036b3a51391755c2c9646165c8

Merge pull request dotnet/coreclr#1490 from BruceForstall/FixILTests

Fix IL JIT tests

Commit migrated from https://github.com/dotnet/coreclr/commit/a94621aa1fd7544490009baaf00ef3a3536052fc

minor correction

Commit migrated from https://github.com/dotnet/coreclr/commit/090aa8e939a5fcd83b75350ab8dcab95c60a4f65

Merge pull request dotnet/coreclr#1492 from benjamin-hodgson/patch-1

Fix link to API review process documentation

Commit migrated from https://github.com/dotnet/coreclr/commit/6668a9b85352920a958fa5527dda12dc2f5886aa