Compare commits

...
240 Commits
Author SHA1 Message Date
Jo Shields a76b50e5fa Append .1 to version number 2019-03-14 16:18:35 -04:00
Jo Shields 5888bf9acc Include libgdiplus 5.6.1 2019-03-14 16:13:15 -04:00
Alexis Christoforides 91be8bb746 [MacSDK] Bump Nuget to 4.8.2 2019-03-13 14:50:37 +01:00
Alexander Köplinger 9d4aa950aa [ci] Use dl.internalx.com when building on private Jenkins 2019-02-26 11:19:43 +01:00
Alexander Köplinger aac8e69534 [ci] Support building the OSX .pkg on private Jenkins
(cherry picked from commit 7f5125179d)
2019-02-12 16:12:32 +01:00
Alexander Köplinger f880f9f120 [ci] Bump bockbuild to get fontconfig url fix 2019-02-12 16:11:34 +01:00
Lee Culver a4e486da0b Add back missing stack frames to mono MERP reports
Changeset https://github.com/mono/mono/commit/e1461ebc855977667f71d1804fd96eed2a155aff
introduced a regression where only the topmost frame of managed crashes are reported.

This change adds back the missing stack frames.
2019-02-04 17:46:34 +01:00
monojenkins 077179a5dc [jit] Fix a buffer overflow in mini_get_gsharedvt_out_sig_wrapper_signature (). (#12140)
Fixes https://github.com/mono/mono/issues/12130.
2019-01-14 13:40:20 +01:00
Alexander Kyte cf22cf26f6 [crash] Remove missing LLVM_API_SUPPORT symbol usage (#12396) 2019-01-12 12:10:22 +01:00
Alexander Kyte 4ff5c09c29 [2018-06] [merp] Batch of fixes (#12037)
* [crash] Early exit if callbacks not set

* [crash] Report which thread was crashing

* [runtime] Make sure lldb/gdb dump happens when MERP fails

* [crash] Create supervisor thread for crash dumper

* [runtime] Add waitpid to probed-for libc functions

* [crash] Add crash reporter logger

* [crash] Disable mono-merp when disabling crash reporting

* [crash] Switch merp dumper to no-allocate file writer

- Pass merp directory to backend (optional)
- Adds tests that needed the named change

* [crash] Make mono-state use non-allocating format strings

* [crash] Add json formatting validators to mono/tests

* [crash] Make crash-sending icalls use const strings

* [crash] Use fork+exec for merp

* [crash] Throw exception when unable to contact merp

* [runtime] Remove duplicate merp invoke line

Backport of #12036

* [crash] Disable merp-json-valid test on non-OSX

* [crash] Fix state disabler on OSX

* [crash] Fix mono-state writer trailing comma

* [crash] Add missing entry for native method reporting

* [crash] Disable crash logger test on linux

* [backport] Revert API change, disable test
2019-01-11 16:04:38 -02:00
Alexander Köplinger bba4ca2a7c [ci] Clean acceptance-tests/external before build
Otherwise it might have left-over files from previous builds since it
uses our custom submodule system which isn't catched by Jenkins cleaning.

(cherry picked from commit 49a5af74f7)
(cherry picked from commit b429e290e8)
2019-01-11 11:36:42 +01:00
monojenkins c6816aab10 [2018-06] [MacSDK] Bump NuGet to 4.8.1 (#12135)
Backport of #12034.
2018-12-20 13:24:18 +01:00
monojenkins 1dedd6fe94 [aot] Emit runtime invoke wrappers for up to 40 parameters for bitcode, newly added tests depend on it. (#11893)
[2018-06] [aot] Emit runtime invoke wrappers for up to 40 parameters for bitcod…

…e, newly added tests depend on it.

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



<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->


Backport of #11891.

/cc @vargaz
2018-12-18 18:40:28 -05:00
monojenkins ad3edd3484 [crash] Add managed exception class name (#11822) 2018-11-30 13:28:26 -08:00
Bernhard Urban 3b3c10f34e [interp] Compile method for errors when needed (#11836)
[2018-06] [interp] Compile method for errors when needed

Partial backport of https://github.com/mono/mono/pull/10095

This change is also needed for the following situation: On a native-to-managed transition the interpreter executes the `NATIVE_TO_MANAGED` wrapper. This wrapper makes sure that the thread is attached. However, doing `transform` requires an attached thread in some cases (e.g. when you run with `--debug`). This commit makes sure that we transform the `InterpMethod` when the thread is attached, that is, when the entry point for the native-to-managed transition is requested.

FYI: This is already in `2018-08` and up.
2018-11-29 15:35:45 -05:00
Bernhard Urban 6755978fe4 [interp] Don't include internal frames in stack trace (#11795)
For handled exceptions. On unhandled exceptions we leave them for debugging purposes.

Fixes exception18.cs
2018-11-27 14:33:28 -08:00
Bernhard Urban 7aadce3fad [mini] use AOT trampolines in interp mixed mode (#11767) (#11784)
[mini] use AOT trampolines in interp mixed mode

Fixes this on mscorlib/mixed mode on Xamarin.iOS:
```
[FAIL] NonExceptional.Serialization_Deserialization : System.Runtime.Serialization.SerializationException : An error occurred while deserializing the object. The serialized data is corrupt. 
[FAIL] NonExceptional.Serialize_Deserialize_FixedDateRule : System.Runtime.Serialization.SerializationException : An error occurred while deserializing the object. The serialized data is corrupt. 
[FAIL] NonExceptional.Serialize_Deserialize_FloatingDateRule : System.Runtime.Serialization.SerializationException : An error occurred while deserializing the object. The serialized data is corrupt. 
[FAIL] SerializationTests.Serialization_Deserialization : System.Runtime.Serialization.SerializationException : An error occurred while deserializing the object. The serialized data is corrupt. 
[FAIL] TimeZoneTest.CurrentTimeZone_SerializationRoundtrip : System.Runtime.Serialization.SerializationException : An error occurred while deserializing the object. The serialized data is corrupt. 
```
2018-11-26 12:37:57 -08:00
monojenkins 4bc42a8767 [interp] Don't throw exception on -1 division (#11777)
Backport of #9656.
2018-11-26 16:34:44 +01:00
Bernhard Urban b63e5378e3 [2018-06][ios] fix path for llvm invocation (#11737)
Seems like this change got lost when backporting https://github.com/mono/mono/pull/10445. The other branches, 2018-06 and 2018-10, are fine.

This should make the LLVM step on the iOS SDK lane green again.

Context: https://github.com/mono/mono/pull/10440#issuecomment-439461353
2018-11-19 17:31:14 -05:00
monojenkins bb3ae37d71 [interp] attempt to intrinsify again after a method is resolved regarding generics (#11715)
[2018-06] [interp] attempt to intrinsify again after a method is resolved regarding generics

discovered when running https://github.com/Clancey/gMusic



Backport of #11712.

/cc @luhenry @lewurm
2018-11-16 15:15:35 -05:00
monojenkins 78eb5303e8 [2018-06] [aot] image is usable without debug flag when interpreter is used (#11711)
Backport of #11705.
2018-11-16 12:10:49 +01:00
monojenkins 54cc205dd9 [2018-06] [crash] Remove duplicated il_offset (#11703)
This code is duplicated completely from the code directly above it (github doesn't show in this diff)

Backport of #11700.
2018-11-15 23:23:43 +01:00
monojenkins 279ac406e7 [2018-06] [runtime] Fix the size calculation in mono_debug_add_method (). (#11686)
Backport of #11672.
2018-11-15 16:12:37 +01:00
Bernhard Urban 1ac52d1827 [2018-06] [llvm] bump for armhf callingconv fix (#11610)
* [llvm] bump for armhf callingconv fix

Commit list for mono/llvm:

* mono/llvm@f80899cb3e [mono] respect hardfloat/softloat setting in ARM ABI (#16)
* mono/llvm@f80899cb3e (HEAD -> master, origin/master) [mono] respect hardfloat/softloat setting in ARM ABI (#16)
* mono/llvm@37e14bd72e Fix the mono calling convention on arm64+linux.
* mono/llvm@acb33f3436 Pack 32bits llc, opt and llvm-dis in archive as well
* mono/llvm@9b92b4b876 Merge pull request #14 from lateralusX/lateralusX/build-llvm-windows-x64
* mono/llvm@e2ae3309b0 Fixes Mono LLVM usage on Windows x64.
* mono/llvm@384caa9849 Build LLVM Windows x64 using CMake + VS2015 or VS2017.
* mono/llvm@0b3cb8ac12 Emit an LSDA for methods without landing pads too since we need the information about the 'this' register.fbbfbae4fea [ci] Enable x86/amd64 backends. (#9)
* mono/llvm@8e14f6654a Add 3.9 Packaging Scripts and Cross Compilation Support (#8)
* mono/llvm@bdb3a116db Change some code slighly in AArch64InstrInfo.cpp to work around a gcc optimizer problem. https://github.com/xamarin/xamarin-android/issues/1182.
* mono/llvm@3b82b3c904 [ci] Really compile the 32 bit llvm as 32 bit.
* mono/llvm@73c983a02a [ci] Distribute 32 bit llvm-config.
* mono/llvm@0692a5ea23 [ci] Install 64-bit binaries into usr64 for consistency.
* mono/llvm@804c869e6b [ci] Fix 32 bit build.8dfa8ebfc25 [ci] Compile a 32 bit version of llvm as well.07582cba7cc [ci] Package llvm-config as well.
* mono/llvm@a9cfb50e5a [ci] Fix an rm statement which can fail.
* mono/llvm@a21fcae962 Add a jenkins build script.
* mono/llvm@21492ec92e Revert "Add a workaround to the problem where the amd64 JIT would make all calls as register indirect."
* mono/llvm@6aa74ae572 Fix a regression caused by:
* mono/llvm@5056b9f2bc Rename the temp labels used by DwarfMonoException so they don't collide with the ones used by the GNU EH frame.
* mono/llvm@975e3a6903 Align the size of the Mono EH table to 8 to prevent an ld assertion. Fixes #55553.
* mono/llvm@dbb6fdffde [arm] Handle CallingConv::Mono in getEffectiveCallingConv (), previously it would be handled by the default branch, which would fall through to the next switch case because llvm_unreachable() was a noop in release builds.
* mono/llvm@5b94bc7097 Avoid making the EH table symbol global, its not needed any more.
* mono/llvm@8b1520c8aa Merge pull request #6 from Xaltotun/feature/cmake_build
* mono/llvm@8d00fd3845 Fixed MONO_API_VERSION define for the cmake build. For #cmakedefine to work, the variable needs to be declared in the cmake script otherwise it will be commented out in the generated file.
* mono/llvm@73df95d02d Merge pull request #5 from alexanderkyte/mastere
* mono/llvm@51cd999c98 [mono] Fix MONO_API_VERSION usage with cmake

Diff: https://github.com/mono/llvm/compare/9f79399f87282524fee099b328bd8cbf07929daf...f80899cb3eb75f7f5640b4519e83bd96991bffb8

* [arm64] Pass small stack args correctly on linux. Fixes pinvoke.exe with llvm+full aot.

Backport of #10674.
2018-11-14 17:44:05 -05:00
Bernhard Urban eee1d634e8 [ios] remove DISABLE_POLICY_EVIDENCE (#11580)
[2018-06] [ios] remove DISABLE_POLICY_EVIDENCE

Originally it was introduced with db3591b
It seems like only the icall definitions were disabled for device
runtimes (which aren't shipped there anyway), however the icalls
themselves are _included_ in the device runtime. Not sure what the
rationale was behind this. Since the original change is very old, I
think it just happened to be like that today.  When running with the
interpreter we need the definitions at runtime too (via the optional
icall table that is linked in, so no additional cost for the fullAOT
runtime due to this change).

Backport of https://github.com/mono/mono/pull/11565
2018-11-07 00:55:36 -05:00
Alexander Köplinger 4d7b7ab375 [ci] Fix Windows .msi build
(cherry picked from commit c8d59d1d1d)
2018-11-06 10:41:47 +01:00
monojenkins 21dc7470bc [bcl] avoid false pinning in GCTest (#11534) 2018-11-05 21:00:59 -05:00
monojenkins d9779c1df6 [interp] accept typed-by-ref as return type from a JIT call (#11538) 2018-11-05 20:59:34 -05:00
monojenkins e7e14a7929 [interp] transform delegate invoke in method body too (#11549) 2018-11-05 20:58:52 -05:00
Alexander Köplinger cadeaf43da [ci] Switch to new syntax of Azure Storage plugin
(cherry picked from commit de2cb5fdde)
2018-11-05 18:24:00 +01:00
monojenkins 709b46e333 [tests] reduce recursion depth (#11484)
so it doesn't trigger a stack overflow on Xamarin.iOS with interpreter on a debug build (`CFLAGS=-O0`).
2018-10-31 12:46:02 +01:00
Alexander Kyte b291519422 [crash] Fix async setting for crash reporter
We were previously only setting it from the icall. The icall was
therefore fine, while invocations associated with actual dumps
caused crashes like this:

```

thread #10, name = 'Thread Pool Worker'
    frame #0: 0x00007fff978dac22 libsystem_kernel.dylib`__psynch_mutexwait + 10
    frame #1: 0x00007fff979c5dfa libsystem_pthread.dylib`_pthread_mutex_lock_wait + 100
    frame #2: 0x00007fff979c3519 libsystem_pthread.dylib`_pthread_mutex_lock_slow + 285
    frame #3: 0x0000000108e0d4a9 mono`mono_loader_lock + 73
    frame #4: 0x0000000108dc9106 mono`mono_class_create_from_typedef + 182
    frame #5: 0x0000000108dc1f2c mono`mono_class_get_checked + 92
    frame #6: 0x0000000108e21da2 mono`mono_metadata_parse_type_internal + 1378
    frame #7: 0x0000000108e25e11 mono`mono_metadata_parse_mh_full + 1233
    frame #8: 0x0000000108ca4f79 mono`mono_debug_add_aot_method + 121
    frame #9: 0x0000000108cc6b1e mono`decode_exception_debug_info + 5918
    frame #10: 0x0000000108cc5047 mono`mono_aot_find_jit_info + 1367
    frame #11: 0x0000000108e082cc mono`mono_jit_info_table_find_internal + 204
    frame #12: 0x0000000108cdb035 mono`mini_jit_info_table_find_ext + 69
    frame #13: 0x0000000108cdad5c mono`mono_find_jit_info_ext + 124
    frame #14: 0x0000000108cdc3a5 mono`unwinder_unwind_frame + 229
    frame #15: 0x0000000108cdbade mono`mono_walk_stack_full + 798
    frame #16: 0x0000000108cda1a4 mono`mono_summarize_managed_stack + 100
    frame #17: 0x0000000108e6dc03 mono`mono_threads_summarize_execute + 1347
    frame #18: 0x0000000108e6df88 mono`mono_threads_summarize + 360

```
2018-10-31 08:31:16 +01:00
Alexander Kyte 149206a5ee [crash] Fix merp invocation (#11436)
The change which made the handler return (rather than crashing the
runtime) did not consider this control flow path that causes the sigterm
signal handler to trigger the merp dumper if we return.

We now always return.

This was previously so that a random sigterm could be used to trigger a
dump. This isn't really used, and won't work right now anyways
(we don't register it until right before we dump). My fix is to remove
it, and to make the signal handler only work as part of the dumper
machinery.
2018-10-30 19:23:53 +01:00
monojenkins 2f2615ffc8 [2018-06] [delegates] do not use CEE_CALLVIRT for non-virtual methods (#11450)
Backport of #11433.

/cc @lewurm 

Description:
2018-10-30 18:25:49 +01:00
Bernhard Urban 47eb7c55eb [2018-06] [interp] Overflow fixes (#11426)
* [interp] Overflow fixes (#9688)

* [interp] Fix some conv ovf opcodes

* [interp] Correctly hande a few conv ovf cases

For conversion from unsigned value to i1 and i2.

* [interp] Fix multiplication overflow case

* [interp] Remove some constants from code

* [interp] throw overflow exception when {float,double}.NaN is converted to an int type (#11380)

[interp] throw overflow exception when {float,double}.NaN is converted to an int type

A comparison with NaN is always `false`.
2018-10-29 18:37:56 -04:00
Bernhard Urban 3ae42fc38d [2018-06] [aot] add unbox_arbitrary_trampoline for fullaot/interp mixed mode (#11362)
[2018-06] [aot] add unbox_arbitrary_trampoline for fullaot/interp mixed mode

Backport of https://github.com/mono/mono/pull/11321
2018-10-25 15:25:39 -04:00
monojenkins c4f7644e97 [tests] lower recursion depth of PerformNoPinAction (#11325)
so it doesn't overflow the stack when running on macOS with `clang -O0`.
2018-10-25 00:27:40 +02:00
Marek Habersack adeaf3e033 [SDKS, LLVM] Disable detection and use of libxml2 (#11341)
Mono doesn't use libxml2 and neither do the LLVM bits used by Mono when building
the AOT cross-compilers. Presence of `-lxml2` on the command line breaks 32-bit
builds on 64-bit Linux hosts:

    libtool: link: cc -shared  -fPIC -DPIC  -Wl,--whole-archive ./.libs/libmini.a ./.libs/libmono-ee-interp.a ./.libs/libmono-dbg.a ../../mono/metadata/.libs/libmonoruntimesgen.a ../../mono/sgen/.libs/libmonosgen.a ../../mono/utils/.libs/libmonoutils.a ../../mono/eglib/.libs/libeglib.a -Wl,--no-whole-archive  -lLLVMBitWriter -lLLVMAnalysis -lLLVMProfileData -lLLVMObject -lLLVMMCParser -lLLVMMC -lLLVMBitReader -lLLVMCore -lLLVMBinaryFormat -lLLVMSupport -lLLVMDemangle -L$HOME/xamarin-android/external/mono/sdks/out/llvm-llvm32/lib -lz -ltinfo -lxml2 -lstdc++ -lm -lrt -ldl -lpthread  -O0 -ggdb3 -m32 -g -mno-tls-direct-seg-refs -Wl,-export-dynamic   -Wl,-soname -Wl,libmonosgen-2.0.so.1 -o .libs/libmonosgen-2.0.so.1.0.0
    mv -f .deps/libmini_la-aot-runtime-wasm.Tpo .deps/libmini_la-aot-runtime-wasm.Plo
    /usr/bin/ld: skipping incompatible //usr/lib/x86_64-linux-gnu/libxml2.so when searching for -lxml2
    /usr/bin/ld: skipping incompatible //usr/lib/x86_64-linux-gnu/libxml2.a when searching for -lxml2
    /usr/bin/ld: cannot find -lxml2
    collect2: error: ld returned 1 exit status
    make[7]: *** [Makefile:1495: libmonosgen-2.0.la] Error 1

Installation of `libxml2-dev` (on Ubuntu/Debian + friends) for the x86
architecture (or x86_64 architecture on 32-bit host) would be possible but then
it would break the 64-bit build because the 64-bit version of the library would
be absent. It would be a problem if Mono+LLVM actually used xml2, but since it
doesn't we can just disable the feature completely.
2018-10-25 00:24:09 +02:00
Aleksey Kliger (λgeek) 32d1539629 [runtime] Don't init classes in ves_icall_RuntimeTypeHandle_is_subclass_of
We must not get a TLE if referenced types are in an assembly that can't be
loaded.

Backported fix of https://github.com/mono/mono/issues/11123
2018-10-22 18:24:57 +02:00
monojenkins c0fe724379 [aot] Reenable recursion checking when initing shared got entries (#11295)
[2018-06] [aot] Reenable recursion checking when initing shared got entries

Backport of #11258.

/cc @BrzVlad 

Description:
Broken in https://github.com/mono/mono/pull/11190
<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2018-10-20 17:55:37 -04:00
monojenkins f55f7e53e3 [interp] use unsigned conversion for nuint (#11285)
[2018-06] [interp] use unsigned conversion for nuint

Backport of #11259.

/cc @lewurm 

Description:
Fixes `MutableDataTest.Constructor` on Xamarin.iOS with interpreter.

monotouch tests are looking good now with interp-only:
<img width="906" alt="screenshot 2018-10-19 at 11 22 07" src="https://user-images.githubusercontent.com/75403/47209686-3d7b2780-d391-11e8-887f-9e1f39de2026.png">
😬
2018-10-20 14:05:32 -04:00
Bernhard Urban 5986920bdb [2018-06] [arm64] Remove the limitation on the number of nullable arguments for dyncalls (#11266)
* [arm64] Remove the limitation on the number of nullable arguments for dyncalls. (#11186)

* [arm64] Remove the limitation on the number of nullable arguments for dyncalls.

Fixes https://github.com/xamarin/xamarin-macios/issues/4984.

* [amd64] Remove the limitation on the number of nullable arguments for dyncalls.

* [jit] Add tests for dyncalls with lots of nullable arguments.

* fix merge conflict
2018-10-19 23:51:57 +02:00
markusbeth 665a308c39 [WinForms] Propagate the flags from DrawTextInternal to MeasureTextInternal (#11251)
Flags to DrawText never reached MeasureText therefore strings with '&' were measured incorrect when drawn with flag TextFormatFlags.NoPrefix.
Fixes #6352
2018-10-19 12:58:02 +02:00
Alexander Kyte 5ed4143b4f [2018-06] Crash Reporter V2 (#11162)
* [runtime] Add icall to format crashes to disk in uniform way

* [crash] More gentle error handling around stack walking

* [crash] Make self-summarizier not need managed thread state

* [crash] Remove reliance on sgen/gchandles

* [crash] Refactor dumper mechanism

* [crash] Make threads not die during thread dump

* [crash] Add silent option to dumper

* [crash] Print error when unable to dump thread

* [crash] Add icalls to directly trigger telemetry-style walks

* [crash] Increase maximum frame depth

* [crash] Add support for concurrent global dump requests

* [crash] Switch from CAS+Sleep to semaphore for dumper

Locks and GC-Safe regions are both unsafe in a signal handler
context. CAS primitives and the sleep syscall was used before.
Semaphores appear to be safe, enabling the following cleanup.

* [runtime] Make find_method use stack memory for dumper-facing entry point

* [crash] Enable install_state_summarizer on all platforms

* [crash] Dump managed stacks from controlling thread

* [crash] Fix string races with DumpTotal icall

* [crash] Fix space in crash file name

* [crash] Fix lifetime and size checks on mono-state memory

* [runtime] Make sequence point lookup lockless

* [crash] Fix managed exception dumper icall format

* [crash] Add tests for concurrent dumping

* [crash] Print half-completed dump when space runs out

* [crash] Bump static memory for crash string to 500k

Note:
- This memory isn't accessed until we're crashing
- On any modern machine, unused static memory is lazily allocated. When
we access it, the fault will trigger the MMU to map memory for us.
- This is guaranteed to be reentrant and safe. mmap (the alternative) is
surely fairly stable on many systems, but this is not guaranteed. The
documentation pages for mmap specifically claim it as not safe in these async
contexts.

* [crash] Make whitelist lookup lockless

* [crash] Split unmanaged ptrs into method ip + offset

* [crash] Copy safer strings with crash privacy disabled

* [crash] Fix BindingFlags undefined with mcs+linux x64

* [crash] Fix icall declarations for new style

* [crash] Squashed support for  RegisterReportingForNativeLib

* [crash] Disable tests on linux / non-osx platforms
2018-10-19 00:59:38 +02:00
Vlad Brezae f0db92c2b6 [interp] Implement interpreter entry trampolines on amd64 (#10978) (#11165)
* [interp] Avoid unnecessary allocations when pinvoke void functions

* [amd64] Refactor interp pinvoke context computation

* [amd64] Interp trampoline for interpreter entry

* [aot] Don't include interp_in_wrapper when we use entry trampoline

These wrappers take a lot of space in the image.
2018-10-18 15:55:37 -04:00
Alexander Köplinger c1f1a7bfed [ci] Move OSX .pkg build to a separate bot pool
Allows us to better utilize the bockbuild cache.

(cherry picked from commit 229a4673d4)
2018-10-18 16:45:05 +02:00
monojenkins d80ced607b [aot] Ensure shared got entries are initialized before loading methods (#11225)
[2018-06] [aot] Ensure shared got entries are initialized before loading methods

Backport of #11190.

/cc @luhenry @BrzVlad

Description:
Executing aot code that uses them would crash. Fixes random csc crashes.



<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2018-10-18 03:15:29 -04:00
monojenkins d07c626a74 [pkg] Add preinstall which removes existing Mono of the same version (#11209)
Fixes #https://github.com/mono/mono/issues/11202
2018-10-17 22:37:58 +02:00
Ludovic Henry cda3acc57c [sdks] futimens and futimes symbols are missing on anything earlier than 10.13 (#11174)
This breaks when LLVM is built on 10.13+ and the runtimes are built on 10.12.
2018-10-15 22:59:53 -04:00
Alexander Köplinger 226e91a064 Bump xunit-binaries 2018-10-11 17:11:27 -04:00
Ludovic Henry 2343f26706 [sdks] Add cmake toolchain file for LLVM MXE builds (#11056)
We couldn't compile llvmwin{32,64} on Linux because we would try to use {i686,x86_64}-w64-mingw-cmake but it wouldn't exist.
2018-10-10 20:32:11 -04:00
Ludovic Henry 46b723d6b0 [2018-06] [sdks] Create archive targets for pre-building on CI (#10936)
* [sdks] Remove redundant --enable-cxx

* [sdks] Shorten `-m32`/`-m64` parameters detection for runtimes

* [sdks] Build BCL profiles without configure flags

* [sdks] Create archive targets for pre-building on CI

* [sdks] Add BclTemplate to build BCL profiles

This is to avoid building all the profiles in a single `sdks/out/bcl` directory which will be shared between android, ios and wasm.

* [sdks] Use archive-{android,ios,wasm} on CI

* [sdks] Run archive-llvm-llvm{,win}{32,64} on CI

* [sdks] Add download/pack capabilities for LLVM

* [sdks] Ensure LLVM is cloned before trying to download

* [sdks] Simplify call to BclTemplate

* Put xunit tests in mcs/class/lib/PROFILE/tests too

So they are next to their NUnit counterparts.

Move xunit remote executor app to tests dir too and compile it when
compiling the test assembly instead of doing it before running the test.

We need to use an absolute path for the xunit remote executor and it
needs to be in Windows format on Windows since we pass it as an env var
to the xunit tests.

* [sdks] Build LLVM with make in parallel

* [mcs] Make directory dependency as order-only

We would otherwise always rebuild the target since the directory is updated whenever something is added to the directory. This is a common Makefile technique.

* [sdks] Build tests for BCL targets

* [build] Switch to netstandard based xunit
2018-10-10 13:35:45 -04:00
monojenkins ab3c897d68 Merge pull request #10997 from lewurm/2018-06-interp-fixes-for-native-type
[2018-06] [interp] fixes for native type

Backport of https://github.com/mono/mono/pull/10749
2018-10-05 15:35:20 +02:00
Bernhard Urban 914a62ab2e [interp] introduce float R4 stack type 2018-10-05 11:04:55 +02:00
Bernhard Urban 62f23a8365 [interp] support ntype.ToString () 2018-10-05 11:04:07 +02:00
Bernhard Urban 2c48c62e66 [interp] support nfloat.*Infinity 2018-10-05 11:04:06 +02:00
Bernhard Urban 5c5a48b144 [interp] support ntype.Equals () 2018-10-05 11:04:06 +02:00
Bernhard Urban 13e412ee52 [interp] support ntype.CompareTo () 2018-10-05 11:04:05 +02:00
Bernhard Urban a576a799b1 [interp] fix op_implicit/op_explicit conversions for native types
Conversion operators have been mostly broken in the interpreter, for
example conversion from nint to float didn't work. While some
conversions are easy to intrinsify (like nint -> I8), there are harder
cases like nint -> decimal. The JIT actually falls back to the managed
implementation, so let's do this in the interpreter as well.

However the managed implementation expects a pointer to the value type,
i.e. the container type System.nfloat instead of float/double primitives.
In such cases the value is going to be stored in a local and then the
address of its storage is pushed on the stack before invoking the
managed implementation of the conversion.

Added test cases for scenarios observed in Xamarin.iOS.
2018-10-05 11:04:03 +02:00
Rolf Bjarne Kvinge 1d9378713e [sdks/ios] Build libMonoPosixHelper for device architectures, so that zlib-helper.o is created. (#10921) (#10970)
xamarin-macios currently builds zlib-helper.o using mono's source code.

It would be preferrable to use a version built by mono, and since
zlib-helper.o is a byproduct of building libMonoPosixHelper, we need to build
libMonoPosixHelper (we already build it for simulator architectures), even
though we don't need/use libMonoPosixHelper itself.
2018-10-04 11:23:32 -04:00
monojenkins 6e48ad4f7b Merge pull request #10905 from monojenkins/backport-pr-10899-to-2018-06
[2018-06] [runtime] Disable stack guard for main thread on osx

Backport of #10899.

/cc @luhenry @BrzVlad

Description of #10899:
On macOS Mojave, it seems that changing the mapping of stack pages for main thread can lead to corruption bugs.

https://github.com/mono/mono/issues/10802



<!--
Thank you for your Pull Request!

If you are new to contributing to Mono, please try to do your best at conforming to our coding guidelines http://www.mono-project.com/community/contributing/coding-guidelines/ but don't worry if you get something wrong. One of the project members will help you to get things landed.

Does your pull request fix any of the existing issues? Please use the following format: Fixes #issue-number
-->
2018-10-03 17:05:46 +02:00
Vlad Brezae d050e323ed [runtime] Fix undefined pthread_main_np (#10930)
It is exported only when _DARWIN_C_SOURCE is defined.
2018-10-03 10:37:23 +03:00
Maxim Lipnin b549fa7f32 [Reflection] Fix issue with finding types in module using an asterisk as filter criteria 2018-10-02 14:56:01 +02:00
Marek Safar 0dffbef269 Bump corefx to disable more tests 2018-10-02 12:24:05 +02:00
Vlad Brezae 6c46acfe69 [runtime] Disable stack guard for main thread on osx
On macOS Mojave, it seems that changing the mapping of stack pages for main thread can lead to corruption bugs.

https://github.com/mono/mono/issues/10802
2018-10-01 20:30:02 +00:00
monojenkins 46e0249d4c [sdks] One more update to get XA PR builds working on Linux (#10855)
It turns out some Debian versions identify themselves as `Debian GNU/Linux`, add
this string to the list of distributions which have mingw. This *should* fix the
PR builds (fingers crossed)
2018-09-27 21:31:33 -04:00
Marek Safar 910395a05f corefx bump 2018-09-27 17:00:39 +02:00
monojenkins 2cdfb380a3 [2018-06] [System]: Make sure HttpWebRequest observes exceptions on timeout. #10488. (#10732)
* [System]Make sure `HttpWebRequest` observes exceptions on timeout. #10488.

`HttpWebRequest.RunWithTimeoutWorker()` needs to observe the worker task's exception
on timeout to prevent it from being thrown via the `TaskScheduler.UnobservedTaskException`
event.  Fixes #10488.

* Add `TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.OnlyOnCanceled` as suggested by Marek.

* Use 'OnlyFaulted' only.
2018-09-27 10:32:25 -04:00
monojenkins aebef84fa2 [merp] Fix return value handling of posix_spawn (#10828) 2018-09-27 10:30:42 -04:00
monojenkins 59f2dbf28b [sdks] Debian Linux doesn't need to build MXE (#10819)
Debian and its derivatives include full mingw chain (both 64 and 32-bit) and so
they don't need to build the toolchain at all. However, the current detection of
Linux flavor takes into account only Ubuntu and all other distros are configured
to *require* MXE but they do *not* build them.

This commit fixes detection of distros which provide the mingw toolchain in a
way that makes it easy to extend the set of compatible distributions as needed.
In order to mark a distribution as one with MinGW one has to add the `:Distro:`
string to the `LINUX_WITH_MINGW` make variable in `mxe.mk`. The `Distro` string
is whatever the `determine-linux-flavor.sh` script returns.
2018-09-27 10:30:07 -04:00
Ankit Jain 401bce867d Bump msbuild to track mono-2018-06 2018-09-27 11:56:16 +02:00
Marek Safar 65737564b0 Bump corefx 2018-09-26 08:07:56 +02:00
monojenkins 40d991c325 [SDKS] Build host runtime with correct bitness (#10742)
When building 32-bit binaries on a 64-bit system and vice versa, it is necessary
to pass the `-m32` or `-m64` compiler flags, respectively. Failure to do so will
result not only in linking problems (different binary architecture) but also in
problems when using some system headers which are sensitive to the architecture.
For instance, `ucontext.h` contains register set definitions for different
architectures and building Mono runtime with a 64-bit compiler targetting 32-bit
architecture results in this error:

   .../mono/mono/utils/mono-sigcontext.h:173:74: error: ‘REG_EIP’ undeclared (first use in this function); did you mean ‘REG_RIP’?
      #define UCONTEXT_REG_EIP(ctx) (((ucontext_t*)(ctx))->uc_mcontext.gregs [REG_EIP])

The issue here is that the compiler defines the `__x86_64__` macro which causes
`ucontext.h` to choose declarations for amd64 (which does not use `REG_EIP` but
has `REG_RIP` instead) while Mono runtime assumes its building for a 32-bit host
and uses 32-bit register names. Passing `-m32` to the compiler will fix the
issue as now the compiler will define the `__i386__` macro and all parties will
agree where they are and what they want.

This commit uses a rather baroque statement when constructing compiler flags to
build the Mono runtime to check whether the host triple targets 32 or 64-bit
host and adds the appropriate flag.
2018-09-24 13:52:54 -04:00
Alexander Kyte 1a71d5101f [crash] Fix summarize_frame assertion 2018-09-21 09:26:33 +02:00
Egor Bogatov 8f36212ad3 [2018-06] Ignore some xunit tests for XA (non compatible with xunit 2.4) (#10721)
* disable some not compatible with xunit 2.4 tests

* bump corefx
2018-09-20 16:51:48 -04:00
Marek Safar 410792459a [corlib] Makes remoting test more robust (and disable it on mobile) 2018-09-20 17:49:26 +02:00
monojenkins 7dd65f79a5 [mono-api-html] Render something for fields with marshalling info. (#10698)
Fixes this warning when comparing Xamarin.iOS.dll:

    Comparison resulting in no changes (src: Public, HasFieldMarshal dst: Public) :
    <field name="EdgeTessellationFactor" attrib="4102" fieldtype="System.UInt16[]" />
    <field name="EdgeTessellationFactor" attrib="6" fieldtype="System.UInt16[]" />
2018-09-19 17:16:29 -04:00
monojenkins 7c898271e7 [offset-tool] Error out when parsing fails. (#10696) 2018-09-19 17:16:02 -04:00
monojenkins adbb8f72c8 [2018-06] Implement IEnumerable for ConditionalWeakTable (#10657)
* Implement IEnumerable for ConditionalWeakTable

* Update ConditionalWeakTable.cs
2018-09-19 12:16:35 -04:00
monojenkins 1b18f39e46 [arm64] Fix the alignment of valuetypes passed after small primitive types on IOS. (#10591)
Fixes https://github.com/xamarin/xamarin-macios/issues/4347.
2018-09-14 08:23:23 -04:00
monojenkins e0221129db [runtime] Fix Marshal.SizeOf (typeof (void)). (#10601)
Fixes https://github.com/mono/mono/issues/10303.
2018-09-14 08:21:24 -04:00
Marek Safar fbaeba4fec [2018-06][Facades] Removes duplicate entry 2018-09-13 13:54:00 +02:00
monojenkins e944415e26 [csproj] Update project files 2018-09-13 09:37:14 +02:00
monojenkins 01d8b4ca55 Bump API snapshot submodule 2018-09-13 09:37:14 +02:00
Marek Safar b84f201e1b [Facades] Adds System.Buffers mobile facade
and sets up facades without corresponding nuget _._ for conflict
resolution done by msbuild
2018-09-13 09:37:14 +02:00
monojenkins e6e4f15474 Treat EXDEV from clonefile the same way as ENOTSUP. (#10530)
Backport of #10528.

/cc @akoeplinger
2018-09-12 13:56:56 -04:00
Zoltan Varga 89cabf4205 [arm64] Add dyncall support for ArgVtypeByRefOnStack arguments.
Fixes https://github.com/mono/mono/issues/10483.
2018-09-11 08:57:27 +02:00
Ankit Jain 8d13a8428d Bump msbuild 2018-06 branch to track xplat-master (#10383) 2018-09-07 23:55:47 +02:00
Alexander Köplinger 5e81afa90d [ci] Fix run-test-mac-sdk.sh build
0dbcdd5 added CFLAGS etc in front of the command but that's not something the TESTCMD can execute.
We shouldn't pass CFLAGS etc at all for this since that is handled by bockbuild.
2018-09-07 17:19:52 +02:00
monojenkins 6b3dfce0c8 [2018-06] Ensure the finalization in DeflateStream is performed in the correct order. (#10491)
* Ensure the finalization of SafeHandle and GCHandle in DeflateStreamNative is performed in the correct order.

* Do not access BaseStream from finalizer.
2018-09-06 18:54:15 -04:00
Alexander Köplinger b34a4d9f57 [2018-06] Bump corefx to get https://github.com/mono/corefx/pull/131 (#10473) 2018-09-06 18:46:53 -04:00
Alexander Kyte 033a5184d1 [2018-06] [runtime] Fix mxe+release_60 llvm build (#10402)
* Add LLVM AOT/Full AOT support on Windows x64.

Uses mono LLVM master branch, build using cmake and VisualStudio 2015/2017.
Commit adds support for AOT/Full AOT LLVM codegen for Windows x64 Visual Studio
build mono runtime. Normal configure/make using cygwin won’t support LLVM and will
trigger an error if configured.

In order to build using LLVM first mono LLVM master branch must be build using
static linked LLVM configuration (dynamic loading can be added later),
NOTE mono LLVM build needs to include the following commit,
https://github.com/mono/llvm/commit/9b92b4b87607e137266f84dc307181b8842fe54a
in order to successfully build on Windows x64.

Build mono LLVM branch using the following cmake configuration:

-DCMAKE_BUILD_TYPE=Release
-DLLVM_ENABLE_ZLIB=OFF
-DLLVM_TARGETS_TO_BUILD="X86"
-DCMAKE_CROSSCOMPILING=False
-DCMAKE_SYSTEM_NAME=Windows

Use cmake with -G "Visual Studio 14 2015 Win64" to generate VS 2015 x64
targets. NOTE, if mono runtime is build using VS 2017, then LLVM should
be build using the same VS version using -G "Visual Studio 15 2017 Win64"

To enable LLVM build in mono.sln, set MONO_ENABLE_LLVM to “true” and make
sure MONO_LLVM_INSTALL_DIR_PREFIX points to the install directory used in
LLVM build above, default msvc/dist/llvm. Above LLVM properties can also
be set if build using msbuild.

A sample LLVM configure script has been included in msvc/llvm-cmake-config.bat.

* Fix build issue on OSX.

* [llvm] Fix build with MXE

* [runtime] Fix mxe+release_60 llvm build

* [sdks] Enable package-android-cross-{arm,arm64,x86,x86_64}-win builds on CI

* [llvm] Fix mxe+release_60 build
2018-09-06 13:52:51 -04:00
monojenkins 9439ee6dca Merge pull request #10455 from lewurm/2018-06-osx-clonefile
[2018-06] Use clonefile instead of copyfile on macOS

* Revert of https://github.com/mono/mono/pull/10010 
* Backport of https://github.com/mono/mono/pull/10020

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


/cc @filipnavara
2018-09-05 07:35:06 -04:00
Neale Ferguson d02452fc8f Reapply #10254 to 2018-06 and include change in #10393 (#10469)
The early change to make MonoTlsStream IDisposable had to be backed out of 2018-06. This restores that fix and includes the fix from #10393 that fixed the reason for the back out.
2018-09-05 08:24:51 +02:00
Alexander Köplinger 3671c04b8e Update framework assemblies list in assembly.c 2018-09-04 16:16:54 +02:00
Martin Baulig 6029509bab [System]Fix MonoBtlsProvider.CheckValidationResult () logic. 2018-09-04 16:15:57 +02:00
monojenkins 4cd817955f [2018-06] Truncate MachineName (and UserDomainName) at first period (#10419)
Backport of #9843.

* Truncate MachineName (and UserDomainName) at first period

Unix machines often put their FQDN as the host name, and domain
name is used for things such as yp. As such, truncate the FQDN to
just the hostname, as other Unix utilities seem to do.

Matches the .NET Core and .NET Framework behaviour, and MS seems to
require this for a future project. Fixes #9839.

* Add a unit test for bug

* Formatting tweaks
2018-09-04 13:21:03 +02:00
monojenkins fc2c8b6435 [2018-06] [corlib] Bring back String.Concat with __arglist (#10458)
Backport of #10452.
Fixes #9996
Tested repro project from the link on a local PostgresSQL server and EntityFramework packages.

See https://github.com/aspnet/EntityFramework6/blob/master/src/EntityFramework/Core/Objects/ELinq/MethodCallTranslator.cs#L1482-L1497
2018-09-04 13:14:23 +02:00
Filip Navara 0d9c68bf13 Use clonefile instead of copyfile on macOS. (#10020)
* Use clonefile instead of copyfile on macOS.

* Address PR review comments.

* Address PR review comments (if -> assert).

* RTLD_DEFAULT - > libc_handle
2018-09-03 23:53:01 +02:00
Bernhard Urban 99f3086330 Revert "[w32file] Fix usage of copyfile (#10010)"
This reverts commit 341142d765.
2018-09-03 23:43:53 +02:00
Ludovic Henry 330eec3b4c Bump to llvm/master/acb33f34 (#10440) 2018-09-02 07:07:12 -04:00
monojenkins 3a18dce583 [interp] white list nfloat::IsNaN () (#10384) 2018-09-01 10:03:54 -04:00
monojenkins b7043700bf [sgen] Fix string size inconsistency between alloc/scan (#10409)
This could lead to crashes when having strings with size at the LOS boundary.

https://github.com/mono/mono/issues/10309
2018-09-01 10:03:35 -04:00
Ludovic Henry b5fa84934f [2018-06] [sdks] Add cross-{arm,arm64,x86,x86_64}{,-win} runtimes for XA + Unify provisioning of LLVM for both Android and iOS. (#10398)
* [sdks] Add CrossRuntimeTemplate

* [sdks] Add cross-{arm,arm64,x86,x86_64}{,-win} runtimes for XA

* [sdks] Factor various variables for RuntimeTemplate

* [sdks] Use CrossRuntimeTemplate for iOS

* [sdks] Unify provisioning of LLVM for both Android and iOS.

A global CFLAGS would be set in `run-jenkins.sh`, and that would screw up with LLVM. The global CFLAGS makes sense as long as we are only building Mono, but that's not the case with LLVM anymore.

* [sdks] Use MonoRuntime template for desktop-x86_64
2018-09-01 09:31:54 -04:00
Jo Shields ac8b05bd71 Merge pull request #10420 from directhex/fix-make-dist-wasm-debugger
Fix `make dist`, broken by 6dc01610e5
2018-08-31 12:13:02 -04:00
Jo Shields d25f967908 Fix make dist, broken by 6dc01610e5 2018-08-31 12:11:17 -04:00
Martin Baulig c8b810e9d7 Revert "[2018-06] [System]: MonoTlsStream is now IDisposable and cleans up on error. (#10391)
Revert PR #10336.

This reverts commit 3bb7817ffd.
2018-08-30 21:22:56 +02:00
monojenkins 633db89a80 Merge pull request #10347 from lewurm/2018-06-interp-fix-ftnptr-eh-callback
[2018-06] [interp] fix ftnptr_eh_callback

Backport of https://github.com/mono/mono/pull/10224
2018-08-30 12:16:17 -04:00
Alexander Köplinger 324d70ea30 [runtime] Run update_submodules.sh earlier (#10365)
Backport of #9646
2018-08-30 11:21:43 +02:00
Ludovic Henry 43e7e83cb1 [sdks] Allow for overwriting llvm-{llvm32,llvm64} CC and CXX (#10360) 2018-08-29 22:11:14 -04:00
Bernhard Urban 58ca70df3b [2018-06] [mini] fix memory dumping on devices (#10351)
[2018-06] [mini] fix memory dumping on devices 

Backport of https://github.com/mono/mono/pull/10316
2018-08-29 19:40:11 -04:00
Zoltan Varga f9c42ea716 [2018-06] [jit] Fix a constant propagation problem on 32 bit with iconst+conv.i… (#10102)
* [jit] Fix a constant propagation problem on 32 bit with iconst+conv.i8, we would be setting inst_imm even for long opcodes.

Fixes https://github.com/xamarin/xamarin-macios/issues/4618.

* [llvm] Fix the special casing of OP_LCOMPARE_IMM, its not needed.
2018-08-29 14:41:51 +02:00
monojenkins 3bb7817ffd [2018-06] [System]: MonoTlsStream is now IDisposable and cleans up on error. (#10336)
Backport of #10254.

/cc @marek-safar
2018-08-29 14:01:42 +02:00
Bernhard Urban fb2708d019 [interp] turn off optimizations for callers of INTERP_PUSH_LMF_WITH_CTX 2018-08-29 11:13:16 +02:00
Bernhard Urban 6dc01610e5 [interp] attach LMF with MonoContext in interp2native transition
this is needed so that EH can resume into the interpreter when the
exception was raised via mono_raise_exception from native code.
2018-08-29 11:11:58 +02:00
Bernhard Urban 12940800a9 [exceptions] pop lmf stack before executing ftnptr_eh_callback 2018-08-29 11:08:37 +02:00
Zoltan Varga ca79abc9b8 [jit] Disable tail calls from gsharedvt code for now.
Fixes https://github.com/mono/mono/issues/9870.
2018-08-28 12:00:16 +02:00
Alexander Kyte 57e9fc6413 [2018-06] Add pipeline to convert managed exception into telemetry format (#10247) 2018-08-27 15:57:06 -04:00
monojenkins 02bc3c5101 [2018-06] System.Windows.Forms: Fix regressions in layout code and TextBox Font handling (#10306)
Backport of #10238.

/cc @filipnavara
2018-08-27 21:32:45 +02:00
Marek Habersack 421e62dd05 [eglib] Fix URI to file name conversion
Hexadecimal ASCII to decimal integer conversion must be 10-based.
2018-08-24 09:22:38 +02:00
Alexander Köplinger 0955dd2307 Bump xunit-binaries
Gets in fix for invalid NUnit xml output generated by xunit
2018-08-22 13:14:04 +02:00
monojenkins a51f37f6c5 An implementation of the ChainStatus property for Btls. (#10216)
When we execute the certificate verification callback we just don't test for success and set status11. Now we get the error (if any) and map the error code to those defined by ChainStatusFlags and add it to a list of X509ChainStatus objects for that chain. Now when get_ChainStatus is called we convert that list to an array of X509ChainStatus and return it.
2018-08-22 11:47:59 +02:00
Alexander Köplinger 16dceddbb9 Bump nunitlite to get NUnit2 xml output fix and failure on file not found fix (#10188)
See mono/NUnitLite#11 and mono/NUnitLite#12

(cherry picked from commit 8f67fb9fb1)
2018-08-20 16:56:22 +02:00
monojenkins 2fbd56f437 Fix process leak in process enumeration. Dispose rejected ones. (#10187)
This https://github.com/mono/mono/issues/10143 and fix is from there.

I considered nulling the array elements as I go, and then the tail,
to help the GC, but does it help actually? I suspect not.
2018-08-20 14:39:15 +02:00
monojenkins baf5e7d9e9 [System.Xml.Linq] Fix namespace conflict with new Xamarin.Mac namespace in test code. (#10183)
macOS 10.14 introduces a Network framework, which means Xamarin.Mac now has a Network namespace.

This conflicts with 'using Network = System.Net':

> mono/mcs/class/System.Xml.Linq/Test/System.Xml.Schema/ExtensionsTest.cs(97,27): error CS0576: Namespace '<global namespace>' contains a definition conflicting with alias 'Network'

so just remove the using and use the full 'System.Net' namespace instead.
2018-08-20 12:10:05 +02:00
monojenkins 680c35dae9 [sdks] Fix local testing for Android (#10175) 2018-08-19 12:11:26 -04:00
monojenkins 192987859f [2018-06] [reflection] Assembly.LoadFile should throw ArgumentException for relative paths (#10083)
* [reflection] Assembly.LoadFile should throw ArgumentException for relative paths

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

* [mcs/tests] Use full path in the compiler-tester

Otherwise the call to LoadFile will fail

* [mono/tests] Use full path in LoadFile in test-multi-netmodule-4-exe

* [mono/tests] Use the test runner for a couple of tests

* [fullaot] Disable test-multi-netmodule-4-exe and custom-attr-errors.exe

* [tests] Use Path.GetFullPath and Path.Combine in AssemblyTest

Fix windows test failures
2018-08-17 09:27:34 -04:00
Ludovic Henry b59ae60011 [sdks] Fix llvm build with MXE (#10106) 2018-08-15 08:39:20 -04:00
Aleksey Kliger (λgeek) 53a0e8f7a8 [2018-06][reflection] Implement RuntimeType.IsSubclassOf in native (#10078)
* [reflection] Implement RuntimeType.IsSubclassOf in native

Fixes a performance regression https://github.com/mono/mono/issues/10000

* fixup - byref and reflexive IsSubclassOf
2018-08-15 00:09:20 -04:00
monojenkins bf5706e3da [bcl] Disable a test which fails with linking. (#10104)
Fixes https://github.com/xamarin/xamarin-macios/issues/4617.
2018-08-15 01:04:35 +02:00
Alexander Köplinger 6dc3229b41 Add .gitignore for mono/tests/assembly-load-reference 2018-08-14 16:53:20 +02:00
monojenkins 7a9c54ebd4 [ppc] Lower OP_LMUL_IMM. (#10067) 2018-08-13 17:43:51 +02:00
Zoltan Varga 3707b814d2 [sdb] Disable an assert to avoid breaking debugging. (#9987)
Fixes https://github.com/mono/mono/issues/8848.
Fixes https://github.com/mono/mono/issues/9262.
Fixes https://github.com/mono/mono/issues/8627.

Backport of https://github.com/mono/mono/pull/9983.
2018-08-10 13:12:02 -04:00
monojenkins 341142d765 [w32file] Fix usage of copyfile (#10010)
When passing COPYFILE_CLONE, copyfile will not follow a symbolic link on the src file. This is a problem since it breaks File.Copy assumption which, when passed a symbolic link, follows the symbolic link instead of copying it. The bug is visible as soon as you use <Copy /> with msbuild and you try to access the copied file with <Touch /> for example
2018-08-10 11:46:32 -04:00
monojenkins 0456d75b08 [w32file] Fix typo (#10002)
Backport of #10001.

/cc @luhenry
2018-08-09 16:43:05 -04:00
monojenkins 333df6b381 [coop] Thread.JoinInternal should not call mono_error_set_pending_exception (#9972)
[2018-06] [coop] Thread.JoinInternal should not call mono_error_set_pending_exception

Backport of #9948.

/cc @lambdageek
2018-08-09 20:55:23 +02:00
monojenkins bd3321192a [2018-06] [Facades] Adds System.Threading.Tasks.Extensions for mobile profiles (#9977)
* [Facades] Adds System.Threading.Tasks.Extensions for mobile profile

* Bump API snapshot submodule

* [csproj] Update project files
2018-08-09 00:14:23 +02:00
Marek Safar a8b65e127b [build] Bump bootstrap mcs version 2018-08-08 10:42:02 +02:00
Zoltan Varga 679f19711d [sdks] Install the llvm36 versions of opt/llc as well. 2018-08-08 10:12:39 +02:00
Zoltan Varga 925d10ba9c [sdks] Make download-llvm36.sh use different temporary files/directories. 2018-08-07 09:44:21 +02:00
Zoltan Varga 481131ab0d [sdks] Switch the 32 bit cross compilers back to the old llvm 3.6, the new version has too many problems. 2018-08-07 09:44:21 +02:00
Aleksey Kliger 9ae1e9e796 [tests] AOT assembly-load-reference tests 2018-08-07 09:43:45 +02:00
Aleksey Kliger 263244a53a [tests] Test loading references from LoadFrom and LoadFile contexts
The LoadFrom assembly loading context and the individual assembly loading
context (aka LoadFile aka "no context") behave differently when requesting a
referenced assembly - for LoadFile we expect the runtime to probe the appdomain
base, the GAC + MONO_PATH but not the basedir of the requesting assembly.  For
LoadFrom the basedir of the requesting assembly _is_ included.  So the tests
here try all the possible variations.
2018-08-07 09:43:45 +02:00
Aleksey Kliger 88ef07a501 [loader] Use appdomain base dir and loadfrom asmctx hooks
1. If an assembly filename is in the GAC, always open the assembly in default
context.
2. If an assembly filename is in the appdomain search path (base directory or
private bin path) always open the assembly in default context.
3. If an assembly filename is in the base dir of the requesting assembly and
the requesting assembly was in LoadFrom context, always open the assembly in
LoadFrom context.

Fixes https://github.com/mono/mono/issues/9753
and Fixes https://github.com/mono/mono/issues/9542
2018-08-07 09:43:45 +02:00
Aleksey Kliger aa33b264e0 [loader] Add mono_install_asmctx_from_path_hook
Add a hook that can be used to check whether a given path belongs to some
assembly load context.

For example if a given path is in the application base of the current
appdomain, an appdomain hook would set out_asmctx to MONO_ASMCTX_DEFAULT and
return TRUE.
2018-08-07 09:43:45 +02:00
Aleksey Kliger 5d3dd6494c [utils] Add mono_path_filename_in_basedir 2018-08-07 09:43:45 +02:00
Aleksey Kliger efe65c3d32 [loader] Pass requesting assembly to mono_assembly_open_predicate
In LoadFrom and LoadFile icalls, pass the currently executing assembly as the
requesting assembly.
2018-08-07 09:43:45 +02:00
Aleksey Kliger 2d8bc639e2 [loader] Assemblies in individual asmctx can reference assemblies in application base
If an assembly was loaded with LoadFile, it can reference assemblies from the
application base, the GAC or MONO_PATH.

Fixes https://github.com/mono/mono/issues/8575
2018-08-07 09:43:45 +02:00
Aleksey Kliger 0713611287 [loader] Consult asmctx of executing assembly for Assembly.Load
if an assembly in LoadFrom context calls Assembly.Load, the given assembly name
should be tried in the basedir of the executing assembly, and the resulting
loaded assembly should be in LoadFrom context.
2018-08-07 09:43:45 +02:00
Aleksey Kliger c2b0be8c25 [runtime] Add mono_runtime_get_caller_no_system_or_reflection
Exposes an already existing stackwalk that we use to find out who called a
corlib API.
2018-08-07 09:43:45 +02:00
monojenkins 36665cc777 [llvm] Fix OP_ABSF. (#9882)
Fixes https://github.com/mono/mono/issues/9869.
2018-08-06 12:52:24 +02:00
EgorBo 093c0dc3b7 backport #9800 to 2018-06 2018-08-03 14:24:36 +02:00
Ankit Jain e59ebf5413 [msbuild] Bump to point to HEAD of mono-2018-04 msbuild … (#9846)
.. once, msbuild has an updated branch for 2018-06/master, then this
will point to that.

This also picks up fix for https://github.com/xamarin/xamarin-android/issues/1845 .
2018-08-02 00:33:47 +02:00
Vlad Brezae dc815ae562 [interp] Fix span exception throwing 2018-08-01 22:13:32 +02:00
Bernhard Urban 0e0e4a68f9 [LinkerDescriptor] remove remoting feature from MonoMethodMessage
Fixes those failures on Xamarin.iOS:
> 2018-07-30 21:16:19.931 monotouchtest[49618:80799179] error: * Assertion at /Users/builder/jenkins/workspace/xamarin-macios-pr-builder/external/mono/mono/metadata/object.c:7896, condition `init_message_method != NULL' not met
> 2018-07-30 21:16:19.931 monotouchtest[49618:80799179] critical: Stacktrace:
>
> 2018-07-30 21:16:19.932 monotouchtest[49618:80799179] critical:   at <unknown> <0xffffffff>
> 2018-07-30 21:16:19.932 monotouchtest[49618:80799179] critical:   at (wrapper managed-to-native) object.__icall_wrapper_mono_delegate_begin_invoke (object,intptr) <0x00012>
> 2018-07-30 21:16:19.932 monotouchtest[49618:80799179] critical:   at (wrapper delegate-begin-invoke) <Module>.begin_invoke_IAsyncResult__this___AsyncCallback_object (System.AsyncCallback,object) [0x00015] in <643e5a0761d140d1977f1bbd2bd72153>:0
> 2018-07-30 21:16:19.932 monotouchtest[49618:80799179] critical:   at MonoTouchFixtures.AVFoundation.AVAssetImageGeneratorTest.GenerateCGImagesAsynchronously () [0x00021] in /Users/builder/jenkins/workspace/xamarin-macios-pr-builder/tests/monotouch-test/AVFoundation/AVAssetImageGeneratorTest.cs:126
> 2018-07-30 21:16:19.933 monotouchtest[49618:80799179] critical:   at (wrapper runtime-invoke) object.runtime_invoke_void__this__ (object,intptr,intptr,intptr) [0x0004f] in <643e5a0761d140d1977f1bbd2bd72153>:0
> 2018-07-30 21:16:19.933 monotouchtest[49618:80799179] critical:   at <unknown> <0xffffffff>
> 2018-07-30 21:16:19.934 monotouchtest[49618:80799179] critical:   at (wrapper managed-to-native) System.Reflection.MonoMethod.InternalInvoke (System.Reflection.MonoMethod,object,object[],System.Exception&) <0x00012>
> 2018-07-30 21:16:19.934 monotouchtest[49618:80799179] critical:   at System.Reflection.MonoMethod.Invoke (object,System.Reflection.BindingFlags,System.Reflection.Binder,object[],System.Globalization.CultureInfo) [0x0003b] in /Library/Frameworks/Xamarin.iOS.framework/Versions/11.15.0.36/src/Xamarin.iOS/mcs/class/corlib/System.Reflection/MonoMethod.cs:305
> 2018-07-30 21:16:19.934 monotouchtest[49618:80799179] critical:   at System.Reflection.MethodBase.Invoke (object,object[]) [0x00000] in /Library/Frameworks/Xamarin.iOS.framework/Versions/11.15.0.36/src/Xamarin.iOS/mcs/class/referencesource/mscorlib/system/reflection/methodbase.cs:229
> 2018-07-30 21:16:19.934 monotouchtest[49618:80799179] critical:   at NUnit.Framework.Internal.Reflect.InvokeMethod (System.Reflection.MethodInfo,object,object[]) [0x00009] in /Users/builder/jenkins/workspace/xamarin-macios-pr-builder/external/mono/external/nunit-lite/NUnitLite-1.0.0/src/framework/Internal/Reflect.cs:215
> 2018-07-30 21:16:19.935 monotouchtest[49618:80799179] critical:   at NUnit.Framework.Internal.Commands.TestMethodCommand.RunNonAsyncTestMethod (NUnit.Framework.Internal.TestExecutionContext) [0x00000] in /Users/builder/jenkins/workspace/xamarin-macios-pr-builder/external/mono/external/nunit-lite/NUnitLite-1.0.0/src/framework/Internal/Commands/TestMethodCommand.cs:114

Also see
https://github.com/xamarin/xamarin-macios/blob/10d98e67d88231fd41218a93b92d42914550ee10/tools/mtouch/Tuning.cs#L137

@akoeplinger mentions further:
> we even have custom code to preserve MonoMethodMessage in the XI linker:
> https://github.com/xamarin/xamarin-macios/blob/a563a66c342d2e982a9648fbfd5ce9c361bea07e/tools/linker/MonoTouch.Tuner/RemoveCode.cs#L178-L180

Fixes regression introduced by https://github.com/mono/mono/pull/8055
2018-08-01 16:34:18 +02:00
Zoltan Varga 7bcda192a0 Bump llvm to release_60/fc854b8ec5873d294b80afa3e6cf6a88c5c48886. (#9786). (#9804) 2018-07-30 22:36:22 +02:00
monojenkins 23e95ec7ad Apply F# portable pdb debug fix for pinvokes & bump (#9797)
It wasn't possible to debug any F# app that contained PInvokes.
The F# compiler omitted MethodDebuginformation for PInvokes which in
turn caused Mono to fail on an assertion.

```
* Assertion at metadata.c:1117, condition `idx < t->rows' not met
```
2018-07-30 12:42:53 +02:00
monojenkins 295f6d32af [2018-06] [MacOS] On Mac, use the copyfile API to copy files (#9696)
Backport of #9642.

/cc @lewurm
2018-07-25 21:07:25 +02:00
monojenkins 7d5f4b6136 [2018-06] [interp] add Span\u003cT\u003e intrinsics for get_Item and get_Length (#9686)
[2018-06] [interp] add Span\u003cT\u003e intrinsics for get_Item and get_Length

Backport of #9644.

/cc @lewurm
2018-07-23 08:40:15 -04:00
Bernhard Urban 1569c8957e [mini] return gracefully from compile_special if a method can not be compiled
the caller will check `error` anyway. It allows the machinery to try the
interpreter instead.
2018-07-23 11:28:48 +02:00
Vlad Brezae cd7f2e39ce [interp] Remove unused code added recently 2018-07-20 10:40:36 -04:00
Vlad Brezae 07144a0840 [interp] Simplify call
Needed also for exception checking, which is done in the wrapper, instead of pinvoke interp code.
2018-07-20 10:40:36 -04:00
Vlad Brezae 31bb7caeb5 [interp] Remove exception checking from pinvoke code
Exception checking is done by the m2n wrapper
2018-07-20 10:40:36 -04:00
Vlad Brezae 3b2e09e46a [interp] Fix stackframe iteration
Interp to managed are not real frames
2018-07-20 10:40:36 -04:00
Vlad Brezae 78b279d3ac [interp] Transform more calls in interp_transform_calls
This also includes m2n wrappers for icalls, which were missing and are needed (ex. for handle stack clearing)
2018-07-20 10:40:36 -04:00
Vlad Brezae b02990a2b6 [interp] Move MINT_CALLRUN emitting inside transform
Also optimize MINT_CALLRUN a bit
2018-07-20 10:40:36 -04:00
Vlad Brezae 3c7dbafd13 [interp] Extract some code from big function 2018-07-20 10:40:36 -04:00
Bernhard Urban 428eb39755 [TermInfo] fix reading integer value for new file format
16bit vs. 32bit only applies for offsets, not for actual entries in the
file format.

Fixes https://github.com/mono/mono/issues/8340
2018-07-19 17:55:11 -04:00
Marek Safar ab1a051d85 Bump bockbuild 2018-07-19 14:52:12 -04:00
monojenkins e2c2b51c5d [llvm] Avoid using the preserveall calling convention in another place on watchos. (#9577)
Fixes https://github.com/mono/mono/issues/9318.
2018-07-19 12:44:17 +02:00
Bernhard Urban 2ae7a8d425 [2018-06] interp delegate fixes (#9600)
[2018-06] interp delegate fixes

Backport of https://github.com/mono/mono/pull/9029 and https://github.com/mono/mono/pull/9409. The former makes backporting of the latter easier.
2018-07-19 06:39:09 -04:00
Marek Safar f4dbef76c9 [System] Update mobile tests to reflect missing DesignerAttribute
Fixes #8407
2018-07-19 09:31:20 +02:00
Alexander Köplinger a98fecbb2b [corlib] Remove incorrectly included Interop.GetRandomBytes.Mono.cs file from .sources
It was added in https://github.com/mono/mono/commit/2e3c4398a9d0d8e3f86b60e753f3da6393a26897 but doesn't actually exist in 2018-06.
2018-07-18 17:42:32 +02:00
monojenkins 0266011065 Fix LogcatTextWriter_Log interpreting messages it logs, potentially writing random garbage and/or crashing (introduced by https://github.com/mono/mono/commit/984f6484666c2ee6fefec949c81fdff1189c9488) (Fixes https://github.com/xamarin/xamarin-android/issues/1951) (#9615) 2018-07-18 11:41:34 -04:00
monojenkins db81ac1b42 [runtime] Make sigterm dumper send file to merp (#9609) 2018-07-18 11:39:41 -04:00
monojenkins 6716456162 [csproj] Update project files 2018-07-17 19:12:07 +02:00
Marek Safar 49a36f9414 [corlib] Include all span helpers optimizations (#9548) 2018-07-17 19:12:07 +02:00
Zoltan Varga bb47db880f [runtime] Allow --enable-llvm to work with newer llvm versions as well. 2018-07-17 12:59:25 +02:00
monojenkins e74de955c2 [csproj] Update project files 2018-07-16 22:46:08 +02:00
monojenkins 38b9b1a203 Bump API snapshot submodule 2018-07-16 22:46:08 +02:00
Marek Safar a1eb29aff4 Bump corert 2018-07-16 22:46:08 +02:00
Marek Safar 894e552a6b Fixes windows build 2018-07-16 22:46:08 +02:00
Marek Safar de669c45a1 [mscorlib] Adds PreserveDependencyAttribute 2018-07-16 22:46:08 +02:00
Marek Safar 2e3c4398a9 [corlib] Default to fast Span<T> (#9204) 2018-07-16 22:46:08 +02:00
Marek Safar d7985272b7 [System.Data] Add missing API in PNS version of SqlConnection 2018-07-15 22:25:01 +02:00
Zoltan Varga b9dd9d11a7 [sdb] Add back the mono_debugger_agent_parse_options () API function which was mistakenly removed by #7673. 2018-07-14 20:35:27 +02:00
monojenkins d735f2f104 [2018-06] [sdks] add interp-mixed to iOS SDK (#9514)
* [sdks] add interp-mixed to iOS SDK

AOT compile mscorlib, everything else runs in the interpreter

* [interp] fix class accessor
2018-07-14 10:49:36 +02:00
monojenkins 2214d1fa74 [2018-06] [dist] Ensure gensources.cs is included in tarballs (#9516)
* [dist] Ensure gensources.cs is included in tarballs

* Add gensources.sh
2018-07-14 10:46:25 +02:00
monojenkins c25f8e3289 [arm64] Make OP_CHECK_THIS read only a byte, to prevent unaligned access errors. (#9544) 2018-07-14 10:44:51 +02:00
monojenkins 32ce5c4dfc [2018-06] [interp] Optimise allocation path (#9513)
Backport of #9443.

/cc @marek-safar
2018-07-13 23:15:07 +02:00
Atsushi Eno f126e2e3c7 [sdk] Do not fix android platform-tools version. Make it configurable. 2018-07-13 22:43:46 +02:00
Jay Krell fa45833f9b Restore the ability to regenerate opcode.def form Perl/XML, though CI cannot and does not. 2018-07-13 22:43:09 +02:00
Alexander Köplinger 604d5e516b Merge pull request #9485 from alexanderkyte/2018-06-merp_params
[Backport 2018-06] Add merp parameters
2018-07-12 21:16:21 +02:00
monojenkins 7c379ca7ca [2018-06] [jit] Add Span\u003cT\u003e intrinsics. (#9515)
[2018-06] [jit] Add Span\u003cT\u003e intrinsics.

Backport of #9086.

/cc @marek-safar
2018-07-12 14:55:50 -04:00
Marek Safar d1db5c5c90 [mcs] Implements awaited expression check for indirections 2018-07-12 12:22:49 +02:00
Alexander Kyte 633745f1b7 [runtime] Enable application to register path for MERP restart 2018-07-11 17:12:45 -04:00
Alexander Kyte 81499e9509 [runtime] Make merp eventType icall argument 2018-07-11 17:12:45 -04:00
Zoltan Varga 308794335c Mixed testing
backport of https://github.com/mono/mono/pull/9021
2018-07-11 16:40:42 -04:00
Bernhard Urban 8bb5d2b97e [ios sdk] add interp-only support
backport of https://github.com/mono/mono/pull/9427
2018-07-11 16:40:42 -04:00
Bernhard Urban 28c3ba27b9 [interp] fullaotmixedcheck fixes
backport of https://github.com/mono/mono/pull/9461
2018-07-11 16:40:42 -04:00
Zoltan Varga 78a5be344a [runtime] Store the interpreter method invoked by the delegate in MonoDelegate.interp_method, make MonoDelegate.method_ptr always point to a JIT callable entry point. (#9019)
backport of https://github.com/mono/mono/pull/9019
2018-07-11 16:40:42 -04:00
Bernhard Urban a520836ddb [sdks] build more runtimes, simulators and cross compilers on CI 2018-07-11 10:50:25 +02:00
Bernhard Urban a5370bdc53 [bitcode] fix build regression of tvos and watchos
caused by 5e9af502c0
2018-07-11 10:50:25 +02:00
Zoltan Varga 69640dfafd [llvm] Avoid using the preserveall calling convention on watchos, xcode10 asserts on it.
Fixes https://github.com/mono/mono/issues/9318.
2018-07-10 10:59:19 +02:00
Bernhard Urban de745ad3e3 [interp] fix scope issue regarding klass var
`klass` exists in the main loop, but we defined `klass` again inside the
block, so the outer `klass` never had the right value.

Fixes https://github.com/mono/mono/issues/9023
2018-07-10 10:58:34 +02:00
Bernhard Urban 6e514dcc64 [mini] make interp work with AOT image generated with aot=interp
backport of https://github.com/mono/mono/pull/9295
2018-07-10 10:12:19 +02:00
Bernhard Urban adf9b386ad [mini] signature cache does not do need_direct_wrapper and virtual_. but needs info to identify signatures for valuetypes 2018-07-09 18:30:33 +02:00
Bernhard Urban 7c3a3b100e [mini] respect additional flags when caching runtime invoke wrappers
depending on `virtual_` and `need_direct_wrapper` we generate slightly
different IL. The interpreter always set `need_direct_wrapper`, but the
JIT doesn't, so this gets problemantic with mixed mode. We need to be
careful when we cache those results.
2018-07-09 18:30:33 +02:00
Alexis Christoforides 2115f2790c Merge pull request #9446 from monojenkins/backport-pr-9440-to-2018-06
[2018-06] Add another Darwin file system
2018-07-06 19:03:17 -04:00
Miguel de Icaza 329ff0292b Add another Darwin file system
This prevents a test failure when Time Machine partitions are mounted on the
host running the test.
2018-07-06 14:49:07 +00:00
Alexander Köplinger 9cf74ba929 Bump bockbuild 2018-07-02 23:17:01 +02:00
monojenkins 972cb658d4 [mini] add workaround for AMD Ryzen Threadripper issue (#9359)
[2018-06] [mini] add workaround for AMD Ryzen Threadripper issue

Backport of #9321.

/cc @lewurm
2018-06-30 08:25:07 -04:00
Marek Safar 6da47b0ac0 [build] Skips RemoteExecuted bases tests on monodroid
The proper implementation will be written later
2018-06-29 14:34:01 +02:00
monojenkins bff2c0f348 [2018-06] [sdks] Only rebuild MXE when it doesn't exist, not when we just cloned the sources (#9366)
* [sdks] Only rebuild MXE when it doesn't exist, not when we just cloned the sources

* [sdks] Default to ~/android-toolchain and ~/android-archives to better share with XA
2018-06-29 14:16:04 +02:00
monojenkins 331fd2a800 [2018-06] Make requested MERP file format changes (#9331)
* [merp] Change and emit event type

* [merp] Change XML file output path
2018-06-28 17:36:03 +02:00
Marek Safar 3a56983dc7 Bump linker 2018-06-28 14:49:14 +02:00
monojenkins 8df9adc649 [runtime] Make mono-state dumper abandon stuck threads (#9272)
Threads which do things with signals and locks may end up unresponsive
to our signals. I cannot get threads that crash in a lock to respond to
SIGTERM on Darwin even if I explicitly unmask SIGTERM on those threads.

In order to defensively program against platform bugs around signals and
stubborn threads, we need to be able to abandon these threads and
continue, dumping other threads.
2018-06-27 12:29:27 +02:00
monojenkins 04d8499a2f [2018-06] [runtime] Package merp params in 3 ways needed (#9269)
* [runtime] Package merp params in 3 ways needed

* [runtime] Use GUID rather than assembly name in json
2018-06-27 12:29:09 +02:00
Alexander Köplinger ebf5f386c9 Formatting 2018-06-26 13:03:35 +02:00
Kadirov Yurij 907ca9a609 Fixes #9277 with @marek-safar recommendations 2018-06-26 13:03:35 +02:00
Kadirov Yurij 2e15d8e879 Unix-only exception on Windows fix #9277 2018-06-26 13:03:35 +02:00
monojenkins b5483fb5e9 [profiler] account for nullbyte in allocated buffer (#9201)
Backport of #9166.
2018-06-25 23:18:43 +02:00
monojenkins fcc7e6f763 [2018-06] [System]: HttpWebRequest now throws WebExceptionStatus.RequestCanceled on abort. (#9294)
* [System]`HttpWebRequest` now throws `WebExceptionStatus.RequestCanceled` on abort. #9031.

Cleanup the internal `HttpWebRequest.RunWithTimeout()` function and use
`GetWebException()` everywhere to throw `WebException` with
`WebExceptionStatus.RequestCanceled` on abort.

New tests for this will be added to the web-tests by extending the existing
`Xamarin.WebTests.HttpInstrumentationTests.AbortDuringHandshake` to check the
synchronous and begin/end async APIs as well, using both `GET` and `POST`.

See https://github.com/xamarin/web-tests/blob/master/Xamarin.WebTests.Tests/Xamarin.WebTests.HttpInstrumentationTests/AbortDuringHandshake.cs.

Fixes #9031.

* Fix exception checks, setting `TransferEncoding` without `SendChunked` is supposed to throw `InvalidOperationException`.

* Fix the incorrect behavior in this test.

Backport of #9212.
2018-06-25 23:17:13 +02:00
monojenkins 18906e7242 [2018-06] [System]: Renegotiation in AppleTls requires OS X 10.12+. (#9255)
* [System]Renegotiation in AppleTls requires OS X 10.12+.

* Make renegotiation version check conditional to `!MONOTOUCH`.

The rest of the renegotiation code is currently conditional to `!MONOTOUCH`
as well, we might want to eventually revisit this at some point.

Fixes #9234

Backport of #9254.
2018-06-25 23:09:57 +02:00
monojenkins d4471210ac [2018-06] [System]: Fix bug in WebResponseStream.GetResponse() that will make some people happy. (#9242)
* [System]Fix bug in `WebResponseStream.GetResponse()` that will make some people happy.

* Cosmetic improvements of the debugging code.
2018-06-22 18:09:46 +02:00
Ankit Jain df1b71eff4 Bump msbuild to track xplat-master (#9247) 2018-06-22 01:12:48 +02:00
Aleksey Kliger 9ec4d30693 [loader] LoadFrom of problematic images should reprobe (correctly)
This reverts commit a2bed67b6b
which itself reverted 9ad5255338

Additionally cherrypick 60f06e6ca2: refonly load
of problematic image is allowed.
2018-06-19 16:41:06 -04:00
Rodrigo Kumpera 3ee5a5cc3d [corlib] Allow DM with an extra param to have the first one bound to null. Fixes #9033. 2018-06-19 10:34:31 +02:00
Bernhard Urban bedea5a1d4 [interp] check existence of InterpMethod before removing it from interp code hastable
when creating dynamic methods, we put those in a queue so they can be
collected later via `mono_jit_free_method ()`. the interpreter part was
assuming, as soon as we allocate a dynamic method, it will be executed
eventually and therefore an InterpMethod must exist in
`info.interp_code_hash`, but this isn't necessarily the case.
2018-06-18 11:24:34 +02:00
monojenkins 4161518777 Bump corefx (#9117)
Backport of #9020.
2018-06-18 10:23:12 +02:00
monojenkins a23bc0b3b4 [System] Fix another SocketAsyncEventArgs issue for #8871. (#9126)
Backport of #8938.
2018-06-18 09:42:15 +02:00
monojenkins 13f3579291 [Linux,XA build] Fix building of Windows cross-compilers on Ubuntu Linux (#9174)
Ubuntu Linux (possibly others too, but only Ubuntu is tested thus the
limitation) don't need to build or use `mxe`, they instead use mingw packaged
for the distribution, thus making the build faster.

This commit detects the Linux flavor in use and, if it's Ubuntu, configures the
build so that system mingw is used instead of mxe.
2018-06-16 15:17:29 +02:00
monojenkins d904e6b30d [SDKS,Android] Install cmake when provisioning Android SDK (#9141)
Android NDK supports cmake in addition to the older make-based ndk-build as the
build system and Xamarin.Android is in the process of switching the build of its
native bits to cmake. The reason for this switch is that certain parts of
Xamarin.Android (libmonodroid) are built for both the host system and
the Android target. The host system build currently uses hand-crafted code
directly in .csproj to build the native bits while the Android build uses
ndk-build. This results in duplication of code, compiler parameters are
specified in two locations - it is easy to introduce incompatibilities, bug
fixes may be applied only in one scenario etc.

Using cmake allows us to use a single build "script" for all the targets, thus
making the build more reliable. Android SDK has a cmake package which contains
full support for NDK builds and allows us to easily use cmake across all the
supported platforms without having to install cmake on the host system.

This commit adds the cmake package to the Android SDK provisiong process and,
alas, at the same time adds a workaround to properly unpack the package. Unlike
other Android SDK packages, cmake doesn't unpack to a single subdirectory of the
zip root, instead all its files and directories are placed directly in the zip
root. This requires yet another workaround to install the package properly.
2018-06-16 15:15:48 +02:00
Alexander Köplinger cd81c99bac Bump bockbuild to fix environment variables expansion bug (#9178)
Brings in https://github.com/mono/bockbuild/pull/67.

This fixes the msbuild build problem where it'd crash with `error MSB4242: The SDK resolver "NuGetSdkResolver" failed to run. Unexpected failure reading NuGet.Config. Path: '@/external/bockbuild/builds/msbuild-15/artifacts/toolset/restore.proj/$HOME/.config/NuGet/NuGet.Config'.`.

The reason is that bockbuild exported the `XDG_CONFIG_HOME` environment variable with the value `$HOME/.config`. The problem is that the `$HOME` in there is never expanded so it just stays as the literal value.

`XDG_CONFIG_HOME` is later used by e.g. `Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData)` which is what nuget uses to construct the path to NuGet.config - hence why we end up with the weird path.

We now just expand the variables in bockbuild before we pass them on.

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

(cherry-picked from cb54c26f6c)
2018-06-16 10:37:08 +02:00
Rodrigo Kumpera 7627a5f9ee [profiler] Don't raise events until the profiler transitions to the ready state. Fixes #8866.
We can't raise event before that as the profiler depends on too much runtime
infrastructure at this point for it to reliably work.

For example, we need the threading infrastructure to be init'd so we can access the
thread-local profiler state to store events there.
2018-06-14 15:01:34 +02:00
monojenkins a2bed67b6b Revert "[loader] LoadFrom of problematic images should reprobe" (#9124)
This reverts commit 9ad5255338.
2018-06-14 03:17:39 +02:00
Alexander Köplinger ad32d62aa8 Update csproj files
(cherry picked from commit ae5a579e22)
2018-06-14 01:57:30 +02:00
Jay Krell ea3fb0c68f Disable flaky interp thread6 test. (#9059)
(cherry picked from commit 9bc218dc11)
2018-06-13 15:19:23 +02:00
monojenkins f366f9d224 update to Android P final API. (#9076) 2018-06-12 13:14:15 +02:00
Jo Shields 6da055b9c4 Bump version to 5.16 --> (#9015)
* Bump version to 5.16

* Fix monolite build

(cherry picked from commit 3bc113b6df)
2018-06-04 13:08:10 -07:00
304 changed files with 10381 additions and 2993 deletions

No files matched your search

+41 -41
View File
@@ -4,7 +4,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
MinimumVisualStudioVersion = 15.0.0.0
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jay", "mcs/jay/jay.vcxproj", "{5D485D32-3B9F-4287-AB24-C8DA5B89F537}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corlib", "mcs/class/corlib/corlib.csproj", "{4627BDAB-CA24-40D0-A627-01692BA51B44}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "corlib", "mcs/class/corlib/corlib.csproj", "{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Security", "mcs/class/Mono.Security/Mono.Security.csproj", "{117140AC-A163-4B86-9E69-A46EA268A9DB}"
EndProject
@@ -745,46 +745,46 @@ Global
{5D485D32-3B9F-4287-AB24-C8DA5B89F537}.Release|winaot.ActiveCfg = Release|Win32
{5D485D32-3B9F-4287-AB24-C8DA5B89F537}.Debug|xammac.ActiveCfg = Debug|Win32
{5D485D32-3B9F-4287-AB24-C8DA5B89F537}.Release|xammac.ActiveCfg = Release|Win32
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|net_4_x.Build.0 = Debug|net_4_x
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|net_4_x.ActiveCfg = Release|net_4_x
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|net_4_x.Build.0 = Release|net_4_x
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monodroid.ActiveCfg = Debug|monodroid
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monodroid.Build.0 = Debug|monodroid
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monodroid.ActiveCfg = Release|monodroid
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monodroid.Build.0 = Release|monodroid
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monotouch.ActiveCfg = Debug|monotouch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monotouch.Build.0 = Debug|monotouch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monotouch.ActiveCfg = Release|monotouch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monotouch.Build.0 = Release|monotouch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monotouch_tv.ActiveCfg = Debug|monotouch_tv
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monotouch_tv.Build.0 = Debug|monotouch_tv
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monotouch_tv.ActiveCfg = Release|monotouch_tv
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monotouch_tv.Build.0 = Release|monotouch_tv
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monotouch_watch.ActiveCfg = Debug|monotouch_watch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|monotouch_watch.Build.0 = Debug|monotouch_watch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monotouch_watch.ActiveCfg = Release|monotouch_watch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|monotouch_watch.Build.0 = Release|monotouch_watch
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|orbis.ActiveCfg = Debug|orbis
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|orbis.Build.0 = Debug|orbis
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|orbis.ActiveCfg = Release|orbis
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|orbis.Build.0 = Release|orbis
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|unreal.ActiveCfg = Debug|unreal
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|unreal.Build.0 = Debug|unreal
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|unreal.ActiveCfg = Release|unreal
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|unreal.Build.0 = Release|unreal
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|wasm.ActiveCfg = Debug|wasm
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|wasm.Build.0 = Debug|wasm
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|wasm.ActiveCfg = Release|wasm
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|wasm.Build.0 = Release|wasm
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|winaot.ActiveCfg = Debug|winaot
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|winaot.Build.0 = Debug|winaot
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|winaot.ActiveCfg = Release|winaot
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|winaot.Build.0 = Release|winaot
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|xammac.ActiveCfg = Debug|xammac
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Debug|xammac.Build.0 = Debug|xammac
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|xammac.ActiveCfg = Release|xammac
{4627BDAB-CA24-40D0-A627-01692BA51B44}.Release|xammac.Build.0 = Release|xammac
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|net_4_x.Build.0 = Debug|net_4_x
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|net_4_x.ActiveCfg = Release|net_4_x
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|net_4_x.Build.0 = Release|net_4_x
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monodroid.ActiveCfg = Debug|monodroid
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monodroid.Build.0 = Debug|monodroid
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monodroid.ActiveCfg = Release|monodroid
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monodroid.Build.0 = Release|monodroid
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monotouch.ActiveCfg = Debug|monotouch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monotouch.Build.0 = Debug|monotouch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monotouch.ActiveCfg = Release|monotouch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monotouch.Build.0 = Release|monotouch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monotouch_tv.ActiveCfg = Debug|monotouch_tv
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monotouch_tv.Build.0 = Debug|monotouch_tv
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monotouch_tv.ActiveCfg = Release|monotouch_tv
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monotouch_tv.Build.0 = Release|monotouch_tv
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monotouch_watch.ActiveCfg = Debug|monotouch_watch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|monotouch_watch.Build.0 = Debug|monotouch_watch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monotouch_watch.ActiveCfg = Release|monotouch_watch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|monotouch_watch.Build.0 = Release|monotouch_watch
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|orbis.ActiveCfg = Debug|orbis
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|orbis.Build.0 = Debug|orbis
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|orbis.ActiveCfg = Release|orbis
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|orbis.Build.0 = Release|orbis
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|unreal.ActiveCfg = Debug|unreal
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|unreal.Build.0 = Debug|unreal
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|unreal.ActiveCfg = Release|unreal
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|unreal.Build.0 = Release|unreal
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|wasm.ActiveCfg = Debug|wasm
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|wasm.Build.0 = Debug|wasm
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|wasm.ActiveCfg = Release|wasm
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|wasm.Build.0 = Release|wasm
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|winaot.ActiveCfg = Debug|winaot
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|winaot.Build.0 = Debug|winaot
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|winaot.ActiveCfg = Release|winaot
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|winaot.Build.0 = Release|winaot
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|xammac.ActiveCfg = Debug|xammac
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Debug|xammac.Build.0 = Debug|xammac
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|xammac.ActiveCfg = Release|xammac
{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}.Release|xammac.Build.0 = Release|xammac
{117140AC-A163-4B86-9E69-A46EA268A9DB}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{117140AC-A163-4B86-9E69-A46EA268A9DB}.Debug|net_4_x.Build.0 = Debug|net_4_x
{117140AC-A163-4B86-9E69-A46EA268A9DB}.Release|net_4_x.ActiveCfg = Release|net_4_x
+36 -35
View File
@@ -1,7 +1,7 @@
# Process this file with autoconf to produce a configure script.
#AC_PREREQ([2.62])
AC_INIT(mono, [5.15.0],
AC_INIT(mono, [5.16.1],
[https://github.com/mono/mono/issues/new])
AC_CONFIG_SRCDIR([README.md])
@@ -40,7 +40,7 @@ MONO_VERSION_BUILD=`echo $VERSION | cut -d . -f 3`
# This can be reset to 0 when Mono's version number is bumped
# since it's part of the corlib version (the prefix '1' in the full
# version number is to ensure the number isn't treated as octal in C)
MONO_CORLIB_COUNTER=7
MONO_CORLIB_COUNTER=16
MONO_CORLIB_VERSION=`printf "1%02d%02d%02d%03d" $MONO_VERSION_MAJOR $MONO_VERSION_MINOR 0 $MONO_CORLIB_COUNTER`
AC_DEFINE_UNQUOTED(MONO_CORLIB_VERSION,$MONO_CORLIB_VERSION,[Version of the corlib-runtime interface])
@@ -521,7 +521,7 @@ AC_SUBST(export_ldflags)
AC_PROG_LD
AC_PROG_LD_GNU
AC_CHECK_HEADERS(sys/filio.h sys/sockio.h netdb.h utime.h sys/utime.h semaphore.h sys/un.h linux/rtc.h sys/syscall.h sys/mkdev.h sys/uio.h sys/param.h sys/sysctl.h libproc.h sys/prctl.h)
AC_CHECK_HEADERS(sys/filio.h sys/sockio.h netdb.h utime.h sys/utime.h semaphore.h sys/un.h linux/rtc.h sys/syscall.h sys/mkdev.h sys/uio.h sys/param.h sys/sysctl.h libproc.h sys/prctl.h copyfile.h)
AC_CHECK_HEADERS(sys/param.h sys/socket.h sys/ipc.h sys/utsname.h alloca.h ucontext.h pwd.h sys/select.h netinet/tcp.h netinet/in.h unistd.h sys/types.h link.h asm/sigcontext.h sys/inotify.h arpa/inet.h complex.h unwind.h)
AC_CHECK_HEADERS([linux/netlink.h linux/rtnetlink.h],
[], [], [#include <stddef.h>
@@ -2331,7 +2331,7 @@ if test x$host_win32 = xno; then
AC_CHECK_HEADERS(pthread.h)
AC_CHECK_HEADERS(pthread_np.h)
AC_CHECK_FUNCS(pthread_mutex_timedlock)
AC_CHECK_FUNCS(pthread_getattr_np pthread_attr_get_np pthread_setname_np pthread_cond_timedwait_relative_np)
AC_CHECK_FUNCS(pthread_getattr_np pthread_attr_get_np pthread_getname_np pthread_setname_np pthread_cond_timedwait_relative_np)
AC_CHECK_FUNCS(pthread_kill)
AC_MSG_CHECKING(for PTHREAD_MUTEX_RECURSIVE)
AC_TRY_COMPILE([ #include <pthread.h>], [
@@ -2797,6 +2797,7 @@ if test x$host_win32 = xno; then
AC_CHECK_FUNCS(setpgid)
AC_CHECK_FUNCS(system)
AC_CHECK_FUNCS(fork execv execve)
AC_CHECK_FUNCS(waitpid)
AC_CHECK_FUNCS(accept4)
AC_CHECK_FUNCS(localtime_r)
AC_CHECK_FUNCS(mkdtemp)
@@ -3733,11 +3734,9 @@ if test "x$enable_llvm" = "xdefault"; then
fi
if test "x$enable_llvm" = "xyes"; then
if test "x$host_win32" = "xno"; then
if test "x$with_llvm" != "x"; then
LLVM_CONFIG=$with_llvm/bin/llvm-config
if test x$host_win32 = xyes; then
LLVM_CONFIG=$LLVM_CONFIG.exe
fi
if test ! -x $LLVM_CONFIG; then
AC_MSG_ERROR([LLVM executable $LLVM_CONFIG not found.])
fi
@@ -3746,27 +3745,28 @@ if test "x$enable_llvm" = "xyes"; then
if test "x$LLVM_CONFIG" = "xno"; then
AC_MSG_ERROR([llvm-config not found.])
fi
if test "x$with_llvm" = "x"; then
with_llvm=`$LLVM_CONFIG --prefix`
fi
fi
llvm_codegen="x86codegen"
LLVM_ARCH_LIBS="-lLLVMX86Disassembler -lLLVMX86CodeGen -lLLVMX86AsmParser -lLLVMX86Desc -lLLVMX86Info -lLLVMX86AsmPrinter -lLLVMX86Utils"
LLVM_ARCH_LIBS=" -lLLVMX86AsmPrinter -lLLVMX86CodeGen -lLLVMX86Desc -lLLVMX86Info -lLLVMX86Utils -lLLVMMCDisassembler"
case "$target" in
arm*)
llvm_codegen="armcodegen"
LLVM_ARCH_LIBS="-lLLVMARMDisassembler -lLLVMARMCodeGen -lLLVMARMAsmParser -lLLVMARMDesc -lLLVMARMInfo -lLLVMARMAsmPrinter"
LLVM_ARCH_LIBS="-lLLVMARMAsmPrinter -lLLVMARMCodeGen -lLLVMARMDesc -lLLVMARMInfo -lLLVMARMUtils -lLLVMMCDisassembler"
;;
aarch64*)
llvm_codegen="aarch64codegen"
LLVM_ARCH_LIBS="-lLLVMARMDisassembler -lLLVMARMCodeGen -lLLVMARMAsmParser -lLLVMARMDesc -lLLVMARMInfo -lLLVMARMAsmPrinter"
LLVM_ARCH_LIBS="-lLLVMAArch64AsmPrinter -lLLVMAArch64CodeGen -lLLVMAArch64Desc -lLLVMAArch64Info -lLLVMAArch64Utils"
;;
powerpc*)
llvm_codegen="powerpccodegen"
LLVM_ARCH_LIBS="-lLLVMPowerPCDisassembler -lLLVMPowerPCCodeGen -lLLVMPowerPCAsmParser -lLLVMPowerPCDesc -lLLVMPowerPCInfo -lLLVMPowerPCAsmPrinter"
LLVM_ARCH_LIBS="-lLLVMPowerPCAsmPrinter -lLLVMPowerPCCodeGen -lLLVMPowerPCDesc -lLLVMPowerPCInfo -lLLVMPowerPCUtils"
;;
esac
if test "x$host_win32" = "xno"; then
# Should be something like '2.6' or '2.7svn'
llvm_version=`$LLVM_CONFIG --version`
llvm_api_version=`$LLVM_CONFIG --mono-api-version 2>/dev/null`
@@ -3822,22 +3822,25 @@ if test "x$enable_llvm" = "xyes"; then
expected_llvm_version="3.4svn-mono-mono/e656cac"
else
LLVM_CFLAGS="-I$with_llvm/include -DNDEBUG -D__NO_CTYPE_INLINE -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS"
LLVM_CXXFLAGS="$LLVM_CFLAGS -std=gnu++11 -fvisibility-inlines-hidden -fno-rtti -Woverloaded-virtual -Wcast-qual"
LLVM_CFLAGS="-I$with_llvm/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -DNDEBUG"
LLVM_CXXFLAGS="-I$with_llvm/include -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -DNDEBUG -fno-rtti -fexceptions -std=gnu++11"
LLVM_LDFLAGS="-L$with_llvm/lib"
LLVM_SYSTEM_LIBS="-lshell32 -lpsapi -limagehlp -ldbghelp -lm"
LLVM_LIBS="-lLLVMLTO -lLLVMObjCARCOpts -lLLVMLinker -lLLVMipo -lLLVMVectorize -lLLVMBitWriter \
-lLLVMTableGen -lLLVMDebugInfo -lLLVMOption -lLLVMSelectionDAG -lLLVMAsmPrinter \
-lLLVMMCDisassembler -lLLVMJIT -lLLVMAnalysis -lLLVMTarget \
-lLLVMIRReader -lLLVMAsmParser -lLLVMLineEditor -lLLVMMCAnalysis -lLLVMInstrumentation \
-lLLVMInterpreter -lLLVMCodeGen -lLLVMScalarOpts -lLLVMInstCombine -lLLVMTransformUtils \
-lLLVMipa -lLLVMAnalysis -lLLVMProfileData -lLLVMMCJIT -lLLVMTarget -lLLVMRuntimeDyld \
-lLLVMObject -lLLVMMCParser -lLLVMBitReader -lLLVMExecutionEngine -lLLVMMC -lLLVMCore \
-lLLVMSupport -lstdc++"
LLVM_LIBS="$LLVM_LIBS $LLVM_ARCH_LIBS $LLVM_SYSTEM_LIBS"
llvm_config_path=$with_llvm/include/llvm/Config/llvm-config.h
llvm_api_version=`awk '/MONO_API_VERSION/ { print $3 }' $llvm_config_path`
case "$target" in
arm*)
LLVM_LIBS="-lLLVMARMCodeGen -lLLVMGlobalISel -lLLVMSelectionDAG -lLLVMAsmPrinter -lLLVMDebugInfoCodeView -lLLVMDebugInfoMSF -lLLVMCodeGen -lLLVMTarget -lLLVMScalarOpts -lLLVMInstCombine -lLLVMTransformUtils -lLLVMBitWriter -lLLVMAnalysis -lLLVMProfileData -lLLVMObject -lLLVMMCParser -lLLVMBitReader -lLLVMCore -lLLVMBinaryFormat -lLLVMARMDesc -lLLVMMCDisassembler -lLLVMARMInfo -lLLVMARMAsmPrinter -lLLVMARMUtils -lLLVMMC -lLLVMSupport -lLLVMDemangle"
;;
aarch64*)
LLVM_LIBS="-lLLVMAArch64CodeGen -lLLVMGlobalISel -lLLVMSelectionDAG -lLLVMAsmPrinter -lLLVMDebugInfoCodeView -lLLVMDebugInfoMSF -lLLVMCodeGen -lLLVMTarget -lLLVMScalarOpts -lLLVMInstCombine -lLLVMTransformUtils -lLLVMBitWriter -lLLVMAnalysis -lLLVMProfileData -lLLVMObject -lLLVMMCParser -lLLVMBitReader -lLLVMCore -lLLVMBinaryFormat -lLLVMAArch64Desc -lLLVMAArch64Info -lLLVMAArch64AsmPrinter -lLLVMMC -lLLVMAArch64Utils -lLLVMSupport -lLLVMDemangle"
;;
*)
LLVM_LIBS="-lLLVMX86CodeGen -lLLVMGlobalISel -lLLVMX86Desc -lLLVMX86Info -lLLVMMCDisassembler -lLLVMX86AsmPrinter -lLLVMX86Utils -lLLVMSelectionDAG -lLLVMAsmPrinter -lLLVMDebugInfoCodeView -lLLVMDebugInfoMSF -lLLVMCodeGen -lLLVMTarget -lLLVMScalarOpts -lLLVMInstCombine -lLLVMTransformUtils -lLLVMBitWriter -lLLVMAnalysis -lLLVMProfileData -lLLVMObject -lLLVMMCParser -lLLVMMC -lLLVMBitReader -lLLVMCore -lLLVMBinaryFormat -lLLVMSupport -lLLVMDemangle"
;;
esac
LLVM_LIBS="$LLVM_LIBS -lpsapi -lshell32 -lole32 -luuid -ladvapi32 -lz -lstdc++"
llvm_api_version=600
fi
if test "x$llvm_api_version" = "x"; then
@@ -4169,11 +4172,7 @@ if test "x$host" != "x$target"; then
# TEGRA
CPPFLAGS="$CPPFLAGS"
;;
armv5-*-linux-androideabi*)
AC_DEFINE(TARGET_ANDROID, 1, [...])
CPPFLAGS="$CPPFLAGS"
;;
*-linux-androideabi*)
*-linux-android*)
AC_DEFINE(TARGET_ANDROID, 1, [...])
CPPFLAGS="$CPPFLAGS"
;;
@@ -4597,6 +4596,7 @@ AC_DEFINE(HAVE_UWP_WINAPI_SUPPORT, 0, [Don't use UWP Windows API support])
AC_CHECK_FUNCS(strlcpy stpcpy strtok_r rewinddir vasprintf)
AC_CHECK_FUNCS(getrlimit)
AC_CHECK_FUNCS(fork execv execve)
AC_CHECK_FUNCS(waitpid)
AC_ARG_WITH([overridable-allocators], [ --with-overridable-allocators allow g_*alloc/g_free to call custom allocators set via g_mem_set_vtable])
@@ -5499,6 +5499,9 @@ AC_CONFIG_COMMANDS([runtime/etc/mono/4.5/web.config],
AC_CONFIG_COMMANDS([quiet-libtool], [sed -e 's/echo "copying selected/# "copying selected/g' < libtool > libtool.tmp && mv libtool.tmp libtool && chmod a+x libtool; sed -e 's/$ECHO "copying selected/# "copying selected/g' < libtool > libtool.tmp && mv libtool.tmp libtool && chmod a+x libtool])
AC_CONFIG_COMMANDS([nolock-libtool], [sed -e 's/lock_old_archive_extraction=yes/lock_old_archive_extraction=no/g' < libtool > libtool.tmp && mv libtool.tmp libtool && chmod a+x libtool])
# Update all submodules recursively to ensure everything is checked out
$srcdir/scripts/update_submodules.sh
AC_OUTPUT([
Makefile
mono-uninstalled.pc
@@ -5525,6 +5528,7 @@ mono/arch/arm64/Makefile
mono/arch/mips/Makefile
mono/sgen/Makefile
mono/tests/Makefile
mono/tests/assembly-load-reference/Makefile
mono/tests/tests-config
mono/tests/gc-descriptors/Makefile
mono/tests/testing_gac/Makefile
@@ -5579,9 +5583,6 @@ msvc/Makefile
po/Makefile
])
# Update all submodules recursively to ensure everything is checked out
$srcdir/scripts/update_submodules.sh
if test x$host_win32 = xyes; then
# Get rid of 'cyg' prefixes in library names
sed -e "s/\/cyg\//\/\//" libtool > libtool.new; mv libtool.new libtool; chmod 755 libtool
+1 -1
+1 -1
+1 -1
+1 -1
View File
@@ -2,7 +2,7 @@
{
"name": "llvm",
"url": "git://github.com/mono/llvm.git",
"rev": "9f79399f87282524fee099b328bd8cbf07929daf",
"rev": "f80899cb3eb75f7f5640b4519e83bd96991bffb8",
"remote-branch": "origin/master",
"branch": "master",
"directory": "llvm"
+1
View File
@@ -41,6 +41,7 @@ DISTFILES = \
corcompare-api.xsl \
executable.make \
gensources.sh \
gensources.cs \
library.make \
rules.make \
tests.make \
+1 -1
View File
@@ -41,7 +41,7 @@ class X
Version min_mono_version;
#if __MonoCS__
min_mono_version = new Version (5, 13);
min_mono_version = new Version (5, 16);
#else
min_mono_version = new Version (5, 10);
#endif
+3 -3
View File
@@ -32,10 +32,10 @@ mono_libdir = $(exec_prefix)/lib
sysconfdir = $(prefix)/etc
#RUNTIME = mono
RUNTIME = false
MONO_PATH_TOP = $(topdir)/class/lib/$(PROFILE_DIRECTORY)/
MONO_PATH_TOP = $(topdir)/class/lib/$(PROFILE_DIRECTORY)
MONO_PATH_TESTS = $(MONO_PATH_TOP)/tests
TEST_MONO_PATH = $(MONO_PATH_TOP)$(PLATFORM_PATH_SEPARATOR)$(MONO_PATH_TESTS)
TEST_RUNTIME = MONO_PATH="$(TEST_MONO_PATH)$(PLATFORM_PATH_SEPARATOR).$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) --debug
TEST_MONO_PATH = $(MONO_PATH_TOP)$(PLATFORM_PATH_SEPARATOR)$(MONO_PATH_TESTS)$(PLATFORM_PATH_SEPARATOR).
TEST_RUNTIME = MONO_PATH="$(TEST_MONO_PATH)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) --debug
# In case you want to add MCS_FLAGS, this lets you not have to
# keep track of the default value
+1 -1
View File
@@ -6,7 +6,7 @@
PLATFORM_MCS_FLAGS =
PLATFORM_RUNTIME = $(RUNTIME)
PLATFORM_CORLIB = mscorlib.dll
PLATFORM_TEST_HARNESS_EXCLUDES =
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnLinux,
EXTERNAL_MCS = mcs
EXTERNAL_MBAS = mbas
+35 -21
View File
@@ -19,20 +19,34 @@ TEST_RUNTIME_WRAPPERS_PATH = $(shell dirname $(RUNTIME))/_tmpinst/bin
## Unit test support
ifndef NO_TEST
test_lib_dir = $(topdir)/class/lib/$(PROFILE)/tests
test_nunit_lib = nunitlite.dll
xunit_core := xunit.core xunit.execution.desktop xunit.abstractions xunit.assert Xunit.NetCore.Extensions
xunit_core := xunit.core xunit.execution.dotnet xunit.abstractions xunit.assert Xunit.NetCore.Extensions
xunit_deps := System.Runtime
xunit_src := $(patsubst %,$(topdir)/../external/xunit-binaries/%,BenchmarkAttribute.cs BenchmarkDiscover.cs) $(topdir)/../mcs/class/test-helpers/PlatformDetection.cs
ifeq ($(USE_XTEST_REMOTE_EXECUTOR), YES)
XTEST_REMOTE_EXECUTOR = $(topdir)/class/lib/$(PROFILE)/RemoteExecutorConsoleApp.exe
XTEST_REMOTE_EXECUTOR = $(test_lib_dir)/RemoteExecutorConsoleApp.exe
ifeq ($(BUILD_PLATFORM), win32)
XTEST_REMOTE_EXECUTOR_ABSPATH = $(shell cygpath -w $(abspath $(XTEST_REMOTE_EXECUTOR)))
else
XTEST_REMOTE_EXECUTOR_ABSPATH = $(abspath $(XTEST_REMOTE_EXECUTOR))
endif
xunit_src += $(topdir)/../mcs/class/test-helpers/AdminHelper.cs \
$(topdir)/../mcs/class/test-helpers/RemoteExecutorTestBase.Mono.cs \
$(topdir)/../external/corefx/src/CoreFx.Private.TestUtilities/src/System/IO/FileCleanupTestBase.cs \
$(topdir)/../external/corefx/src/CoreFx.Private.TestUtilities/src/System/Diagnostics/RemoteExecutorTestBase.Process.cs \
$(topdir)/../external/corefx/src/CoreFx.Private.TestUtilities/src/System/Diagnostics/RemoteExecutorTestBase.cs \
$(topdir)/../external/corefx/src/Common/src/System/PasteArguments.cs \
$(topdir)/../external/corefx/src/Common/src/System/PasteArguments.Unix.cs
ifeq ($(PROFILE),monodroid)
xunit_src += $(topdir)/../mcs/class/test-helpers/RemoteExecutorTestBase.Mobile.cs
else
xunit_src += $(topdir)/../mcs/class/test-helpers/RemoteExecutorTestBase.Mono.cs \
$(topdir)/../external/corefx/src/CoreFx.Private.TestUtilities/src/System/Diagnostics/RemoteExecutorTestBase.Process.cs
endif
endif
xunit_class_deps :=
@@ -57,6 +71,7 @@ test_sourcefile = $(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
endif
test_lib = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll)
test_lib_output = $(test_lib_dir)/$(test_lib)
test_sourcefile_excludes = $(test_lib).exclude.sources
@@ -68,12 +83,13 @@ ifndef NO_BUILD
test_flags += -r:$(the_assembly)
test_assembly_dep = $(the_assembly)
endif
tests_CLEAN_FILES += $(ASSEMBLY:$(ASSEMBLY_EXT)=_test*.dll) $(ASSEMBLY:$(ASSEMBLY_EXT)=_test*.pdb) $(test_response) $(test_makefrag)
tests_CLEAN_FILES += $(test_lib_output) $(test_lib_output:$(ASSEMBLY_EXT)=.pdb) $(test_response) $(test_makefrag)
xtest_sourcefile = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
xtest_sourcefile_excludes = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.exclude.sources)
xunit_test_lib = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xunit-test.dll)
xtest_lib_output = $(test_lib_dir)/$(xunit_test_lib)
xtest_response = $(depsdir)/$(xunit_test_lib).response
xtest_makefrag = $(depsdir)/$(xunit_test_lib).makefrag
@@ -81,7 +97,7 @@ xtest_flags = -r:$(the_assembly) $(xunit_libs_ref) $(XTEST_MCS_FLAGS) $(XTEST_LI
ifeq ($(wildcard $(xtest_sourcefile)),)
xtest_sourcefile = $(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
tests_CLEAN_FILES += $(xunit_test_lib) $(xtest_response) $(xtest_makefrag)
tests_CLEAN_FILES += $(xtest_lib_output) $(xtest_response) $(xtest_makefrag)
endif
ifndef HAVE_CS_TESTS
@@ -108,10 +124,6 @@ endif
test_assemblies :=
test_lib_dir = $(topdir)/class/lib/$(PROFILE)/tests
test_lib_output = $(topdir)/class/lib/$(PROFILE)/tests/$(test_lib)
ifdef HAVE_CS_TESTS
test_assemblies += $(test_lib_output)
@@ -237,7 +249,7 @@ ifdef HAVE_CS_TESTS
$(test_lib_dir):
mkdir -p $@
$(test_lib_output): $(test_assembly_dep) $(test_response) $(test_nunit_dep) $(test_lib_dir)
$(test_lib_output): $(test_assembly_dep) $(test_response) $(test_nunit_dep) | $(test_lib_dir)
$(TEST_COMPILE) $(LIBRARY_FLAGS) -target:library -out:$@ $(test_flags) $(LOCAL_TEST_COMPILER_ONDOTNET_FLAGS) @$(test_response)
test_response_preprocessed = $(test_response)_preprocessed
@@ -267,7 +279,8 @@ ifdef HAVE_CS_XTESTS
XTEST_HARNESS_PATH := $(topdir)/../external/xunit-binaries
XTEST_HARNESS = $(XTEST_HARNESS_PATH)/xunit.console.exe
XTEST_HARNESS_FLAGS := -noappdomain -noshadow -parallel none -nunit TestResult-$(PROFILE)-xunit.xml
XTEST_RESULT_FILE := TestResult-$(PROFILE)-xunit.xml
XTEST_HARNESS_FLAGS := -noappdomain -noshadow -parallel none -nunit $(XTEST_RESULT_FILE)
XTEST_TRAIT := -notrait category=failing -notrait category=nonmonotests -notrait Benchmark=true -notrait category=outerloop
# The logic is double inverted so this actually excludes tests not intented for current platform
# best to search for `property name="category"` in the xml output to see what's going on
@@ -289,22 +302,23 @@ XTEST_COVERAGE_FLAGS = -O=-aot --profile=coverage:output=$(topdir)/class/lib/$(P
endif
check: run-xunit-test-local
xunit-test-local: $(xunit_test_lib)
xunit-test-local: $(xtest_lib_output)
run-xunit-test-local: run-xunit-test-lib
# cp -rf is a HACK for xunit runner to require xunit.execution.desktop.dll file in local folder on .net only
run-xunit-test-lib: xunit-test-local $(XTEST_REMOTE_EXECUTOR)
@cp -rf $(XTEST_HARNESS_PATH)/xunit.execution.desktop.dll xunit.execution.desktop.dll
# cp -rf is a HACK for xunit runner to require xunit.execution.dOTNET.dll file in local folder on .net only
run-xunit-test-lib: xunit-test-local
@cp -rf $(XTEST_HARNESS_PATH)/xunit.execution.dotnet.dll $(test_lib_dir)/xunit.execution.dotnet.dll
ok=:; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" REMOTE_EXECUTOR=$(XTEST_REMOTE_EXECUTOR) $(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) $(XTEST_COVERAGE_FLAGS) $(AOT_RUN_FLAGS) $(XTEST_HARNESS) $(xunit_test_lib) $(XTEST_HARNESS_FLAGS) $(XTEST_TRAIT) $(XTEST_TRAIT_PLATFORM) || ok=false; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" REMOTE_EXECUTOR="$(XTEST_REMOTE_EXECUTOR_ABSPATH)" $(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) $(XTEST_COVERAGE_FLAGS) $(AOT_RUN_FLAGS) $(XTEST_HARNESS) $(xtest_lib_output) $(XTEST_HARNESS_FLAGS) $(XTEST_TRAIT) $(XTEST_TRAIT_PLATFORM) || ok=false; \
if [ -n "$$MONO_BABYSITTER_NUNIT_XML_LIST_FILE" ]; then echo "$(abspath $(XTEST_RESULT_FILE))" >> "$$MONO_BABYSITTER_NUNIT_XML_LIST_FILE"; fi; \
$$ok
@rm -f xunit.execution.desktop.dll
@rm -f $(test_lib_dir)/xunit.execution.dotnet.dll
# Some xunit tests want to be executed in a separate process (see RemoteExecutorTestBase)
$(XTEST_REMOTE_EXECUTOR): $(topdir)/../external/corefx/src/Common/tests/System/Diagnostics/RemoteExecutorConsoleApp/RemoteExecutorConsoleApp.cs
$(XTEST_REMOTE_EXECUTOR): $(topdir)/../external/corefx/src/Common/tests/System/Diagnostics/RemoteExecutorConsoleApp/RemoteExecutorConsoleApp.cs | $(test_lib_dir)
$(TEST_COMPILE) -r:$(topdir)/class/lib/$(PROFILE)/mscorlib.dll $< -out:$@
$(xunit_test_lib): $(the_assembly) $(xtest_response) $(xunit_libs_dep) $(xunit_src)
$(xtest_lib_output): $(the_assembly) $(xtest_response) $(xunit_libs_dep) $(xunit_src) $(XTEST_REMOTE_EXECUTOR) | $(test_lib_dir)
$(TEST_COMPILE) $(LIBRARY_FLAGS) $(XTEST_LIB_FLAGS) -target:library -out:$@ $(xtest_flags) @$(xtest_response) $(xunit_src)
xtest_response_preprocessed = $(xtest_response)_preprocessed
@@ -316,7 +330,7 @@ $(xtest_response): $(xtest_sourcefile) $(wildcard $(xtest_sourcefile_excludes))
$(xtest_makefrag): $(xtest_response)
@echo Creating $@ ...
@sed 's,^,$(xunit_test_lib): ,' $< >$@
@sed 's,^,$(xtest_lib_output): ,' $< >$@
-include $(xtest_makefrag)
@@ -0,0 +1,35 @@
//
// Copyright (c) 2018 Microsoft
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
using System;
using System.Reflection;
using System.Runtime.CompilerServices;
[assembly: AssemblyTitle ("System.Buffers")]
[assembly: AssemblyDescription ("System.Buffers")]
[assembly: AssemblyDefaultAlias ("System.Buffers")]
[assembly: AssemblyCompany ("Mono development team")]
[assembly: AssemblyProduct ("Mono Common Language Infrastructure")]
[assembly: AssemblyCopyright ("(c) Various Mono authors")]
[assembly: AssemblyVersion ("4.0.99.0")]
[assembly: AssemblyInformationalVersion ("4.0.99.0")]
[assembly: AssemblyFileVersion ("4.0.99.0")]
@@ -0,0 +1,108 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{2FA683C7-0623-4BBB-A95E-8225AB4E3DE6}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Buffers</AssemblyName>
<TargetFrameworkVersion>v2.1</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../Open.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
</Project>
+24
View File
@@ -0,0 +1,24 @@
MCS_BUILD_DIR = ../../../build
thisdir = class/Facades/System.Buffers
SUBDIRS =
include $(MCS_BUILD_DIR)/rules.make
LIBRARY_SUBDIR = Facades
LIBRARY_INSTALL_DIR = $(mono_libdir)/mono/$(FRAMEWORK_VERSION)/Facades
LIBRARY = System.Buffers.dll
KEYFILE = ../../Open.snk
LIBRARY_SNK = $(KEYFILE)
SIGN_FLAGS = /delaysign /nowarn:1616,1699
LIB_REFS =
LIB_MCS_FLAGS = $(SIGN_FLAGS)
PLATFORM_DEBUG_FLAGS =
NO_TEST = yes
include $(MCS_BUILD_DIR)/library.make
@@ -0,0 +1,3 @@
TypeForwarders.cs
AssemblyInfo.cs
@@ -0,0 +1,23 @@
//
// Copyright (c) 2018 Microsoft
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
[assembly:System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Buffers.ArrayPool<>))]
@@ -30,6 +30,6 @@ using System.Runtime.CompilerServices;
[assembly: AssemblyCompany ("Mono development team")]
[assembly: AssemblyProduct ("Mono Common Language Infrastructure")]
[assembly: AssemblyCopyright ("(c) Various Mono authors")]
[assembly: AssemblyVersion ("4.0.1.0")]
[assembly: AssemblyInformationalVersion ("4.0.0.0")]
[assembly: AssemblyFileVersion ("4.0.0.0")]
[assembly: AssemblyVersion ("4.0.99.0")]
[assembly: AssemblyInformationalVersion ("4.0.99.0")]
[assembly: AssemblyFileVersion ("4.0.99.0")]
@@ -0,0 +1,36 @@
//
// Copyright (C) 2018 Microsoft Corporation
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Reflection;
using System.Runtime.CompilerServices;
[assembly: AssemblyTitle ("System.Threading.Tasks.Extensions")]
[assembly: AssemblyDescription ("System.Threading.Tasks.Extensions")]
[assembly: AssemblyDefaultAlias ("System.Threading.Tasks.Extensions")]
[assembly: AssemblyCompany ("Mono development team")]
[assembly: AssemblyProduct ("Mono Common Language Infrastructure")]
[assembly: AssemblyCopyright ("(c) Various Mono authors")]
[assembly: AssemblyVersion ("4.2.0.0")]
[assembly: AssemblyInformationalVersion ("4.0.0.0")]
[assembly: AssemblyFileVersion ("4.0.0.0")]
@@ -0,0 +1,108 @@
<?xml version="1.0" encoding="utf-8"?>
<!-- WARNING: this file is autogenerated, don't modify it. Edit the .sources file of the corresponding assembly instead if you want to add/remove C# source files. -->
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{F1D7CE36-B18B-48F0-B42A-7556448F98BA}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>1699,1616,1699</NoWarn>
<LangVersion>latest</LangVersion>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Windows_NT'">win32</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix' and $([System.IO.File]::Exists('/usr/lib/libc.dylib'))">darwin</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Threading.Tasks.Extensions</AssemblyName>
<TargetFrameworkVersion>v2.1</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../Open.snk</AssemblyOriginatorKeyFile>
</PropertyGroup>
<!-- Set AddAdditionalExplicitAssemblyReferences to false, otherwise if targetting .NET4.0,
Microsoft.NETFramework.props will force a dependency on the assembly System.Core. This
is a problem to compile the Mono mscorlib.dll -->
<PropertyGroup>
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../../class/lib/monodroid/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../../class/lib/monotouch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../../class/lib/monotouch_watch/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../../class/lib/monotouch_tv/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../../class/lib/testing_aot_full/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../../class/lib/winaot/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../../class/lib/xammac/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../../class/lib/orbis/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../../class/lib/unreal/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../../class/lib/wasm/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<!-- TRACE is set only for Debug configuration, so inherit from platform-specific value -->
<DefineConstants>TRACE;$(DefineConstants)</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_full\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
</Project>
@@ -0,0 +1,24 @@
MCS_BUILD_DIR = ../../../build
thisdir = class/Facades/System.Threading.Tasks.Extensions
SUBDIRS =
include $(MCS_BUILD_DIR)/rules.make
LIBRARY_SUBDIR = Facades
LIBRARY_INSTALL_DIR = $(mono_libdir)/mono/$(FRAMEWORK_VERSION)/Facades
LIBRARY = System.Threading.Tasks.Extensions.dll
KEYFILE = ../../Open.snk
LIBRARY_SNK = $(KEYFILE)
SIGN_FLAGS = /delaysign /nowarn:1616,1699
LIB_REFS =
LIB_MCS_FLAGS = $(SIGN_FLAGS)
PLATFORM_DEBUG_FLAGS =
NO_TEST = yes
include $(MCS_BUILD_DIR)/library.make
@@ -0,0 +1,2 @@
AssemblyInfo.cs
TypeForwarders.cs
@@ -0,0 +1,39 @@
//
// Copyright (C) 2018 Microsoft Corporation
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.AsyncMethodBuilderAttribute))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.AsyncValueTaskMethodBuilder<>))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.ConfiguredValueTaskAwaitable<>))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.ValueTaskAwaiter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.ValueTaskAwaiter<>))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Threading.Tasks.ValueTask))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Threading.Tasks.ValueTask<>))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Threading.Tasks.Sources.IValueTaskSource))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Threading.Tasks.Sources.IValueTaskSource<>))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Threading.Tasks.Sources.ValueTaskSourceOnCompletedFlags))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Threading.Tasks.Sources.ValueTaskSourceStatus))]
+2 -2
View File
@@ -90,8 +90,8 @@ unreal_PARALLEL_SUBDIRS = $(common_SUBDIRS) $(mobile_only_SUBDIRS)
wasm_SUBDIRS = $(common_DEPS_SUBDIRS) $(netstandard_drawing_SUBDIRS) $(mobile_only_DEPS_SUBDIRS)
wasm_PARALLEL_SUBDIRS = $(common_SUBDIRS) $(mobile_only_SUBDIRS)
mobile_only_SUBDIRS = System.Security.Cryptography.Pkcs \
System.Security.Cryptography.Cng System.Runtime.Loader System.Xml.XPath.XmlDocument System.Reflection.DispatchProxy System.Memory System.Drawing.Common
mobile_only_SUBDIRS = System.Security.Cryptography.Pkcs System.Threading.Tasks.Extensions System.Memory System.Buffers \
System.Security.Cryptography.Cng System.Runtime.Loader System.Xml.XPath.XmlDocument System.Reflection.DispatchProxy System.Drawing.Common
mobile_only_DEPS_SUBDIRS = System.Security.Cryptography.OpenSsl
+1 -1
View File
@@ -424,7 +424,7 @@ monolite_dir = monolite-$(HOST_PLATFORM)/$(MONO_CORLIB_VERSION)
# Files needed to bootstrap C# compiler and cil-stringreplacer
build_files := mscorlib.dll System.dll System.Xml.dll Mono.Security.dll System.Core.dll System.Security.dll System.Configuration.dll \
System.Numerics.dll System.Xml.Linq.dll System.IO.Compression \
System.Numerics.dll System.Xml.Linq.dll System.IO.Compression.dll \
Facades/System.Collections.Concurrent.dll Facades/System.Linq.dll Facades/System.Runtime.dll Facades/System.Collections.dll \
Facades/System.Reflection.Extensions.dll Facades/System.Text.Encoding.Extensions.dll Facades/System.Diagnostics.Debug.dll \
Facades/System.Reflection.Primitives.dll Facades/System.Text.Encoding.dll Facades/System.Diagnostics.Tools.dll Facades/System.Reflection.dll \
@@ -804,7 +804,7 @@ namespace Mono.Data.Sqlite
int enc;
IntPtr p = UnsafeNativeMethods.sqlite3_context_collseq(context, out type, out enc, out len);
if (p != null) seq.Name = UTF8ToString(p, len);
if (p != IntPtr.Zero) seq.Name = UTF8ToString(p, len);
seq.Type = (CollationTypeEnum)type;
seq._func = func;
seq.Encoding = (CollationEncodingEnum)enc;
+6 -5
View File
@@ -11,17 +11,18 @@ LIB_MCS_FLAGS = /unsafe /publicsign /nowarn:0618
XTEST_LIB_REFS = System System.Core Facades/System.Threading.Tasks
xunit-test-local: log-profiler-test.exe
xunit-test-local: $(topdir)/class/lib/$(PROFILE_DIRECTORY)/tests/log-profiler-test.exe
log-profiler-test.exe: Test/log-profiler-test.cs
$(topdir)/class/lib/$(PROFILE_DIRECTORY)/tests/log-profiler-test.exe: Test/log-profiler-test.cs
mkdir -p $(dir $@)
$(CSCOMPILE) $(PLATFORM_DEBUG_FLAGS) /unsafe $(if $(MCS_MODE),,/warnaserror) /r:$(build_libdir)/mscorlib.dll /r:$(build_lib) /out:$@ $<
EXTRA_DISTFILES = \
Test/log-profiler-test.cs
CLEAN_FILES = \
log-profiler-test.exe \
log-profiler-test.exe.mdb \
log-profiler-test.pdb
$(topdir)/class/lib/$(PROFILE_DIRECTORY)/tests/log-profiler-test.exe \
$(topdir)/class/lib/$(PROFILE_DIRECTORY)/tests/log-profiler-test.exe.mdb \
$(topdir)/class/lib/$(PROFILE_DIRECTORY)/tests/log-profiler-test.pdb
include ../../build/library.make
@@ -37,8 +37,13 @@ namespace MonoTests.Mono.Profiler.Log {
static volatile int _id;
static string _testAssemblyPath;
static Process _currentProcess;
public ProfilerTestRun (string name, string options)
{
_testAssemblyPath = Path.Combine (Path.GetDirectoryName (System.Reflection.Assembly.GetExecutingAssembly ().Location), "log-profiler-test.exe");
_currentProcess = Process.GetCurrentProcess();
Name = name;
Options = options;
_output = $"test-{_id++}.mlpd";
@@ -57,8 +62,8 @@ namespace MonoTests.Mono.Profiler.Log {
using (var proc = new Process ()) {
proc.StartInfo = new ProcessStartInfo {
UseShellExecute = false,
FileName = Path.GetFullPath (Path.Combine ("..", "..", "..", "runtime", "mono-wrapper")),
Arguments = $"--debug --profile=log:nodefaults,output={_output},{Options} log-profiler-test.exe {Name}",
FileName = _currentProcess.MainModule.FileName,
Arguments = $"--debug --profile=log:nodefaults,output=\"{_output}\",{Options} {_testAssemblyPath} {Name}",
};
proc.Start ();
@@ -0,0 +1,11 @@
../../../external/corefx/src/System.ComponentModel.Composition/tests/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/AttributedModel/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/Diagnostics/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/Factories/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/Primitives/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/ComponentModel/Composition/ReflectionModel/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/Integration/*.cs
../../../external/corefx/src/System.ComponentModel.Composition/tests/System/UnitTesting/*.cs
@@ -56,7 +56,7 @@
../../../external/corefx/src/System.Linq.Parallel/tests/Combinatorial/*.cs
../../../external/corefx/src/System.Linq.Parallel/tests/Helpers/*.cs
#../../../external/corefx/src/System.Linq.Parallel/tests/QueryOperators/*.cs
../../../external/corefx/src/System.Linq.Parallel/tests/*.cs:WithCancellationTests.cs,PlinqModesTests.cs,ExchangeTests.cs,EtwTests.cs
../../../external/corefx/src/System.Linq.Parallel/tests/*.cs:WithCancellationTests.cs,PlinqModesTests.cs,ExchangeTests.cs,EtwTests.cs,ParallelEnumerableTests.cs
../../../external/corefx/src/Common/tests/System/Threading/ThreadPoolHelpers.cs
../../../external/corefx/src/Common/tests/System/Diagnostics/Tracing/TestEventListener.cs
../../../external/corefx/src/Common/tests/System/ShouldNotBeInvokedException.cs
@@ -14,6 +14,7 @@ using Microsoft.SqlServer.Server;
using System.Reflection;
using System.IO;
using System.Globalization;
using System.Security;
namespace System.Data.SqlClient
{
@@ -123,6 +124,12 @@ namespace System.Data.SqlClient
public override void ChangeDatabase(string database)
=> throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
public static void ChangePassword(string connectionString, string newPassword)
=> throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
public static void ChangePassword(string connectionString, SqlCredential credential, SecureString newSecurePassword)
=> throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
public static void ClearAllPools()
=> throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
@@ -769,7 +769,7 @@ namespace MonoTests.System.Net.Http
client.SendAsync (request, HttpCompletionOption.ResponseHeadersRead).Wait ();
Assert.Fail ("#1");
} catch (AggregateException e) {
Assert.AreEqual (typeof (ProtocolViolationException), e.InnerException.GetType (), "#2");
Assert.AreEqual (typeof (InvalidOperationException), e.InnerException.GetType (), "#2");
}
Assert.IsNull (failed, "#102");
} finally {
@@ -171,6 +171,8 @@
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\ObjectReferenceStack.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\ObjectToIdCache.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\PrimitiveDataContract.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaExporter.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaHelper.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\ScopedKnownTypes.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SerializationMode.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SerializationPermissionNotRequiredAttribute.cs" />
@@ -267,51 +269,49 @@
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\Configuration\TypeElementCollection.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\ContractCodeDomInfo.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\ImportOptions.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaExporter.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaHelper.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaImporter.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\XsdDataContractImporter.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monodroid' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'winaot' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'xammac' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\CodeExporter.cs" />
@@ -330,26 +330,24 @@
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\Configuration\TypeElementCollection.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\ContractCodeDomInfo.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\ImportOptions.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaExporter.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaHelper.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\SchemaImporter.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="..\referencesource\System.Runtime.Serialization\System\Runtime\Serialization\XsdDataContractImporter.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'orbis' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'unreal' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'wasm' ">
<Compile Include="ReferenceSources\SchemaExporter_mobile.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Private.DataContractSerialization\src\System\Runtime\Serialization\XsdDataContractExporter.cs" />
<Compile Include="corefx\DiagnosticUtility.cs" />
<Compile Include="ReferenceSources\SimplifiedCodeTypeReference.cs" />
<Compile Include="ReferenceSources\XsdDataContractExporter_mobile.cs" />
</ItemGroup>
<!-- @ALL_SOURCES@ -->
<ItemGroup>
@@ -1550,14 +1550,17 @@ namespace MonoTests.System.Runtime.Serialization.Json
public void TestHashtableSerialization ()
{
var collection = new HashtableContainer ();
var expectedOutput = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
var expectedOutput_A = "{\"Items\":[{\"Key\":\"key1\",\"Value\":\"banana\"},{\"Key\":\"key2\",\"Value\":\"apple\"}]}";
var expectedOutput_B = "{\"Items\":[{\"Key\":\"key2\",\"Value\":\"apple\"},{\"Key\":\"key1\",\"Value\":\"banana\"}]}";
var serializer = new DataContractJsonSerializer (collection.GetType ());
var stream = new MemoryStream ();
serializer.WriteObject (stream, collection);
stream.Position = 0;
Assert.AreEqual (expectedOutput, new StreamReader (stream).ReadToEnd (), "#1");
var read = new StreamReader (stream).ReadToEnd ();
Assert.IsTrue (expectedOutput_A == read || expectedOutput_B == read, "#1");
}
[Test]
+6
View File
@@ -142,3 +142,9 @@ notepad.exe: samples/notepad.cs $(topdir)/class/lib/$(PROFILE)/System.Windows.Fo
test-notepad: notepad.exe
$(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) notepad.exe
issue10235.exe: samples/issue10235.cs $(topdir)/class/lib/$(PROFILE)/System.Windows.Forms.dll $(topdir)/class/lib/$(PROFILE)/System.Drawing.dll $(topdir)/class/lib/$(PROFILE)/System.dll $(topdir)/class/lib/$(PROFILE)/mscorlib.dll
$(CSCOMPILE) -out:$@ samples/issue10235.cs -r:$(topdir)/class/lib/$(PROFILE)/System.Windows.Forms.dll -r:$(topdir)/class/lib/$(PROFILE)/System.Drawing.dll -r:$(topdir)/class/lib/$(PROFILE)/System.dll -r:$(topdir)/class/lib/$(PROFILE)/mscorlib.dll
test-issue10235: issue10235.exe
$(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) issue10235.exe
@@ -195,8 +195,13 @@ namespace System.Windows.Forms.Layout
{
IArrangedContainer parent = (IArrangedContainer)container;
LayoutDockedChildren (parent, parent.Controls);
LayoutAnchoredChildren (parent, parent.Controls);
if (parent.Controls is Control.ControlCollection controlCollection) {
LayoutDockedChildren (parent, controlCollection.GetAllControls());
LayoutAnchoredChildren (parent, controlCollection.GetAllControls());
} else {
LayoutDockedChildren (parent, parent.Controls);
LayoutAnchoredChildren (parent, parent.Controls);
}
return parent.AutoSize;
}
@@ -73,6 +73,9 @@ namespace System.Windows.Forms
internal bool has_been_focused;
private bool delayed_font_or_color_change;
private int requested_height;
internal int selection_length = -1; // set to the user-specified selection length, or -1 if none
internal bool show_caret_w_selection; // TextBox shows the caret when the selection is visible
internal int canvas_width;
@@ -163,6 +166,8 @@ namespace System.Windows.Forms
Cursor = Cursors.IBeam;
requested_height = Height;
can_cache_preferred_size = true;
}
#endregion // Internal Constructor
@@ -1008,6 +1013,9 @@ namespace System.Windows.Forms
protected override void OnHandleCreated (EventArgs e)
{
base.OnHandleCreated (e);
if (delayed_font_or_color_change) {
TextBoxBase_FontOrColorChanged (this, e);
}
FixupHeight ();
}
@@ -1467,20 +1475,13 @@ namespace System.Windows.Forms
{
// Make sure we don't get sized bigger than we want to be
if ((specified & BoundsSpecified.Height) != 0) {
requested_height = height;
}
if (!richtext) {
if (!document.multiline) {
if (height != PreferredHeight) {
// If the specified has Height, we need to store that in the
// ExplicitBounds because we are going to override it
if ((specified & BoundsSpecified.Height) != 0) {
Rectangle r = ExplicitBounds;
r.Height = height;
ExplicitBounds = r;
specified &= ~BoundsSpecified.Height;
}
height = PreferredHeight;
}
height = PreferredHeight;
}
}
@@ -1763,13 +1764,15 @@ namespace System.Windows.Forms
private void FixupHeight ()
{
if (!richtext) {
int saved_requested_height = requested_height;
if (!document.multiline) {
if (PreferredHeight != Height) {
SetBoundsCore (Left, Top, Width, PreferredHeight, BoundsSpecified.None);
SetBoundsCore (Left, Top, Width, PreferredHeight, BoundsSpecified.Height);
}
} else {
SetBoundsCore (Left, Top, Width, Math.Max(PreferredHeight, ExplicitBounds.Height), BoundsSpecified.None);
SetBoundsCore (Left, Top, Width, Math.Max(PreferredHeight, requested_height), BoundsSpecified.Height);
}
requested_height = saved_requested_height;
}
}
@@ -2238,8 +2241,10 @@ namespace System.Windows.Forms
{
Line line;
if (!IsHandleCreated)
if (!IsHandleCreated) {
delayed_font_or_color_change = true;
return;
}
document.SuspendRecalc ();
// Font changes apply to the whole document
@@ -318,10 +318,15 @@ namespace System.Windows.Forms
internal static void DrawTextInternal (IDeviceContext dc, string text, Font font, Point pt, Color foreColor, Color backColor, TextFormatFlags flags, bool useDrawString)
{
Size sz = MeasureTextInternal (dc, text, font, useDrawString);
Size sz = MeasureTextInternal (dc, text, font, flags, useDrawString);
DrawTextInternal (dc, text, font, new Rectangle (pt, sz), foreColor, backColor, flags, useDrawString);
}
internal static Size MeasureTextInternal (IDeviceContext dc, string text, Font font, TextFormatFlags flags, bool useMeasureString)
{
return MeasureTextInternal (dc, text, font, Size.Empty, flags, useMeasureString);
}
internal static Size MeasureTextInternal (IDeviceContext dc, string text, Font font, bool useMeasureString)
{
return MeasureTextInternal (dc, text, font, Size.Empty, TextFormatFlags.Default, useMeasureString);
@@ -0,0 +1,172 @@
using System;
using System.Drawing;
using System.Windows.Forms;
namespace Test
{
static class Program
{
/// <summary>
/// Der Haupteinstiegspunkt für die Anwendung.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
this.comboBox1.AutoSize = true; // necessary in Windows .Net to avoid wrong behaviour in TableLayout in particular wrong positioning
this.comboBox1.DataSource = new string[] { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen" };
this.Font = new Font(DefaultFont.FontFamily.Name, DefaultFont.Size * 2.0f); // double font size for the whole form i.e. including all controls
}
/// <summary>
/// Erforderliche Designervariable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Verwendete Ressourcen bereinigen.
/// </summary>
/// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Vom Windows Form-Designer generierter Code
/// <summary>
/// Erforderliche Methode für die Designerunterstützung.
/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
/// </summary>
private void InitializeComponent()
{
this.tableLayoutPanel1 = new System.Windows.Forms.TableLayoutPanel();
this.label1 = new System.Windows.Forms.Label();
this.label2 = new System.Windows.Forms.Label();
this.label3 = new System.Windows.Forms.Label();
this.comboBox1 = new System.Windows.Forms.ComboBox();
this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
this.textBox1 = new System.Windows.Forms.TextBox();
this.tableLayoutPanel1.SuspendLayout();
((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
this.SuspendLayout();
//
// tableLayoutPanel1
//
this.tableLayoutPanel1.ColumnCount = 2;
this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
this.tableLayoutPanel1.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
this.tableLayoutPanel1.Controls.Add(this.label1, 0, 0);
this.tableLayoutPanel1.Controls.Add(this.label2, 0, 1);
this.tableLayoutPanel1.Controls.Add(this.label3, 0, 2);
this.tableLayoutPanel1.Controls.Add(this.comboBox1, 1, 1);
this.tableLayoutPanel1.Controls.Add(this.numericUpDown1, 1, 0);
this.tableLayoutPanel1.Controls.Add(this.textBox1, 1, 2);
this.tableLayoutPanel1.Dock = System.Windows.Forms.DockStyle.Fill;
this.tableLayoutPanel1.Location = new System.Drawing.Point(0, 0);
this.tableLayoutPanel1.Name = "tableLayoutPanel1";
this.tableLayoutPanel1.RowCount = 3;
this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 33.33333F));
this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 33.33333F));
this.tableLayoutPanel1.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 33.33333F));
this.tableLayoutPanel1.Size = new System.Drawing.Size(184, 162);
this.tableLayoutPanel1.TabIndex = 0;
//
// label1
//
this.label1.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.label1.AutoSize = true;
this.label1.Location = new System.Drawing.Point(3, 20);
this.label1.Margin = new System.Windows.Forms.Padding(3);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(35, 13);
this.label1.TabIndex = 0;
this.label1.Text = "label1";
//
// label2
//
this.label2.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.label2.AutoSize = true;
this.label2.Location = new System.Drawing.Point(3, 74);
this.label2.Margin = new System.Windows.Forms.Padding(3);
this.label2.Name = "label2";
this.label2.Size = new System.Drawing.Size(35, 13);
this.label2.TabIndex = 1;
this.label2.Text = "label2";
//
// label3
//
this.label3.Anchor = System.Windows.Forms.AnchorStyles.Left;
this.label3.AutoSize = true;
this.label3.Location = new System.Drawing.Point(3, 128);
this.label3.Margin = new System.Windows.Forms.Padding(3);
this.label3.Name = "label3";
this.label3.Size = new System.Drawing.Size(35, 13);
this.label3.TabIndex = 2;
this.label3.Text = "label3";
//
// comboBox1
//
this.comboBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
this.comboBox1.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList;
this.comboBox1.Location = new System.Drawing.Point(44, 70);
this.comboBox1.Name = "comboBox1";
this.comboBox1.Size = new System.Drawing.Size(137, 21);
this.comboBox1.TabIndex = 4;
//
// numericUpDown1
//
this.numericUpDown1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
this.numericUpDown1.Location = new System.Drawing.Point(44, 17);
this.numericUpDown1.Name = "numericUpDown1";
this.numericUpDown1.Size = new System.Drawing.Size(137, 20);
this.numericUpDown1.TabIndex = 5;
//
// textBox1
//
this.textBox1.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right)));
this.textBox1.Location = new System.Drawing.Point(44, 125);
this.textBox1.Name = "textBox1";
this.textBox1.Size = new System.Drawing.Size(137, 20);
this.textBox1.TabIndex = 6;
this.textBox1.Text = "test";
//
// Form1
//
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.None;
this.ClientSize = new System.Drawing.Size(184, 162);
this.Controls.Add(this.tableLayoutPanel1);
this.Name = "Form1";
this.Text = "Form1";
this.tableLayoutPanel1.ResumeLayout(false);
this.tableLayoutPanel1.PerformLayout();
((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
this.ResumeLayout(false);
}
#endregion
private System.Windows.Forms.TableLayoutPanel tableLayoutPanel1;
private System.Windows.Forms.Label label1;
private System.Windows.Forms.Label label2;
private System.Windows.Forms.Label label3;
private System.Windows.Forms.ComboBox comboBox1;
private System.Windows.Forms.NumericUpDown numericUpDown1;
private System.Windows.Forms.TextBox textBox1;
}
}
@@ -15,6 +15,7 @@ using System.Xml.Serialization;
using System.Collections;
using System.ComponentModel;
using NUnit.Framework;
using System.Linq;
namespace MonoTests.System.XmlSerialization
{
@@ -721,7 +722,7 @@ namespace MonoTests.System.XmlSerialization
public void WriteXml (XmlWriter writer)
{
writer.WriteStartElement ("data");
foreach (DictionaryEntry entry in data)
foreach (DictionaryEntry entry in data.Cast<DictionaryEntry> ().OrderBy (l => l.Key))
{
writer.WriteElementString ((string)entry.Key, (string)entry.Value);
}
@@ -248,9 +248,9 @@
<anyType xsi:type="xsd:string">strings</anyType>
</ttList>aa<xmltext>33</xmltext>bb<xmltext>776</xmltext><special>
<data>
<two>2</two>
<one>1</one>
<three>3</three>
<two>2</two>
</data>
</special><dummyStringArray xmlns="mm">
<ArrayOfString xsi:nil="true" />
@@ -15,7 +15,6 @@ using NUnit.Framework;
using System;
using System.Xml;
using System.IO;
using Network = System.Net;
using System.Xml.Linq;
using System.Xml.Schema;
using System.Collections.Generic;
@@ -94,7 +93,7 @@ namespace MonoTests.System.Xml.Schema
{
// Create a resolver with default credentials.
XmlUrlResolver resolver = new XmlUrlResolver ();
resolver.Credentials = Network.CredentialCache.DefaultCredentials;
resolver.Credentials = global::System.Net.CredentialCache.DefaultCredentials;
// Set the reader settings object to use the resolver.
XmlReaderSettings settings = new XmlReaderSettings ();
settings.XmlResolver = resolver;
@@ -341,10 +341,19 @@ namespace Mono.AppleTls
PeerDomainName = ServerName;
}
if (Options.AllowRenegotiation)
if (Options.AllowRenegotiation && IsRenegotiationSupported ())
SetSessionOption (SslSessionOption.AllowRenegotiation, true);
}
static bool IsRenegotiationSupported ()
{
#if MONOTOUCH
return false;
#else
return Environment.OSVersion.Version >= new Version (16, 6);
#endif
}
void InitializeSession ()
{
if (connectionInfo != null)
@@ -949,19 +958,7 @@ namespace Mono.AppleTls
extern static /* OSStatus */ SslStatus SSLReHandshake (/* SSLContextRef */ IntPtr context);
#endif
public override bool CanRenegotiate {
get {
#if MONOTOUCH
return false;
#else
if (!IsServer)
return false;
if (Environment.OSVersion.Version < new Version (16, 6))
return false;
return true;
#endif
}
}
public override bool CanRenegotiate => IsServer && IsRenegotiationSupported ();
public override void Renegotiate ()
{
+94 -2
View File
@@ -33,6 +33,7 @@ using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Net.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Security.Authentication;
@@ -213,9 +214,100 @@ namespace Mono.Btls
X509Chain chain, MonoBtlsX509StoreCtx storeCtx,
bool success, ref MonoSslPolicyErrors errors, ref int status11)
{
if (!success) {
errors = MonoSslPolicyErrors.RemoteCertificateChainErrors;
status11 = unchecked((int)0);
if (success)
return;
errors = MonoSslPolicyErrors.RemoteCertificateChainErrors;
if (!wantsChain || storeCtx == null || chain == null) {
status11 = unchecked((int)0x800B010B);
return;
}
var error = storeCtx.GetError();
if (error != Mono.Btls.MonoBtlsX509Error.OK &
error != Mono.Btls.MonoBtlsX509Error.CRL_NOT_YET_VALID) {
chain.Impl.AddStatus(MapVerifyErrorToChainStatus(error));
status11 = unchecked((int)0x800B010B);
}
}
internal static X509ChainStatusFlags MapVerifyErrorToChainStatus (MonoBtlsX509Error code)
{
switch (code) {
case MonoBtlsX509Error.OK :
return X509ChainStatusFlags.NoError;
case MonoBtlsX509Error.CERT_NOT_YET_VALID :
case MonoBtlsX509Error.CERT_HAS_EXPIRED:
case MonoBtlsX509Error.ERROR_IN_CERT_NOT_BEFORE_FIELD:
case MonoBtlsX509Error.ERROR_IN_CERT_NOT_AFTER_FIELD:
return X509ChainStatusFlags.NotTimeValid;
case MonoBtlsX509Error.CERT_REVOKED:
return X509ChainStatusFlags.Revoked;
case MonoBtlsX509Error.UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY:
case MonoBtlsX509Error.CERT_SIGNATURE_FAILURE:
return X509ChainStatusFlags.NotSignatureValid;
case MonoBtlsX509Error.CERT_UNTRUSTED:
case MonoBtlsX509Error.DEPTH_ZERO_SELF_SIGNED_CERT:
case MonoBtlsX509Error.SELF_SIGNED_CERT_IN_CHAIN:
return X509ChainStatusFlags.UntrustedRoot;
case MonoBtlsX509Error.CRL_HAS_EXPIRED:
return X509ChainStatusFlags.OfflineRevocation;
case MonoBtlsX509Error.CRL_NOT_YET_VALID:
case MonoBtlsX509Error.CRL_SIGNATURE_FAILURE:
case MonoBtlsX509Error.ERROR_IN_CRL_LAST_UPDATE_FIELD:
case MonoBtlsX509Error.ERROR_IN_CRL_NEXT_UPDATE_FIELD:
case MonoBtlsX509Error.KEYUSAGE_NO_CRL_SIGN:
case MonoBtlsX509Error.UNABLE_TO_DECRYPT_CRL_SIGNATURE:
case MonoBtlsX509Error.UNABLE_TO_GET_CRL:
case MonoBtlsX509Error.UNABLE_TO_GET_CRL_ISSUER:
case MonoBtlsX509Error.UNHANDLED_CRITICAL_CRL_EXTENSION:
return X509ChainStatusFlags.RevocationStatusUnknown;
case MonoBtlsX509Error.INVALID_EXTENSION:
return X509ChainStatusFlags.InvalidExtension;
case MonoBtlsX509Error.UNABLE_TO_GET_ISSUER_CERT:
case MonoBtlsX509Error.UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
case MonoBtlsX509Error.UNABLE_TO_VERIFY_LEAF_SIGNATURE:
return X509ChainStatusFlags.PartialChain;
case MonoBtlsX509Error.INVALID_PURPOSE:
return X509ChainStatusFlags.NotValidForUsage;
case MonoBtlsX509Error.INVALID_CA:
case MonoBtlsX509Error.INVALID_NON_CA:
case MonoBtlsX509Error.PATH_LENGTH_EXCEEDED:
case MonoBtlsX509Error.KEYUSAGE_NO_CERTSIGN:
case MonoBtlsX509Error.KEYUSAGE_NO_DIGITAL_SIGNATURE:
return X509ChainStatusFlags.InvalidBasicConstraints;
case MonoBtlsX509Error.INVALID_POLICY_EXTENSION:
case MonoBtlsX509Error.NO_EXPLICIT_POLICY:
return X509ChainStatusFlags.InvalidPolicyConstraints;
case MonoBtlsX509Error.CERT_REJECTED:
return X509ChainStatusFlags.ExplicitDistrust;
case MonoBtlsX509Error.UNHANDLED_CRITICAL_EXTENSION:
return X509ChainStatusFlags.HasNotSupportedCriticalExtension;
case MonoBtlsX509Error.HOSTNAME_MISMATCH:
// FIXME: we should have a better error flag for this.
return X509ChainStatusFlags.UntrustedRoot;
case MonoBtlsX509Error.CERT_CHAIN_TOO_LONG:
throw new CryptographicException ();
case MonoBtlsX509Error.OUT_OF_MEM:
throw new OutOfMemoryException ();
default:
throw new CryptographicException ("Unrecognized X509VerifyStatusCode:" + code);
}
}
@@ -142,6 +142,11 @@ namespace Mono.Btls
return mono_btls_x509_store_ctx_get_error (Handle.DangerousGetHandle (), out error_string_ptr);
}
public int GetErrorDepth ()
{
return mono_btls_x509_store_ctx_get_error_depth (Handle.DangerousGetHandle ());
}
public MonoBtlsX509Exception GetException ()
{
IntPtr error_string_ptr;
@@ -25,6 +25,7 @@
// THE SOFTWARE.
#if SECURITY_DEP && MONO_FEATURE_BTLS
using System;
using System.Collections.Generic;
using System.Text;
using System.Security;
using System.Security.Cryptography;
@@ -42,6 +43,7 @@ namespace Mono.Btls
X509Certificate2Collection untrusted;
X509Certificate2[] certificates;
X509ChainPolicy policy;
List<X509ChainStatus> chainStatusList;
internal X509ChainImplBtls (MonoBtlsX509Chain chain)
{
@@ -124,7 +126,16 @@ namespace Mono.Btls
}
public override X509ChainStatus[] ChainStatus {
get { throw new NotImplementedException (); }
get {
return chainStatusList.ToArray();
}
}
public override void AddStatus (X509ChainStatusFlags errorCode)
{
if (chainStatusList == null)
chainStatusList = new List<X509ChainStatus>();
chainStatusList.Add (new X509ChainStatus(errorCode));
}
public override bool Build (X509Certificate2 certificate)
@@ -77,7 +77,7 @@ namespace Mono.Net.Security
Settings = settings;
Provider = provider;
readBuffer = new BufferOffsetSize2 (16834);
readBuffer = new BufferOffsetSize2 (16500);
writeBuffer = new BufferOffsetSize2 (16384);
operation = Operation.None;
}
@@ -50,7 +50,7 @@ using System.Security.Cryptography;
namespace Mono.Net.Security
{
class MonoTlsStream
class MonoTlsStream : IDisposable
{
#if SECURITY_DEP
readonly MonoTlsProvider provider;
@@ -136,6 +136,7 @@ namespace Mono.Net.Security
request.ServicePoint.UpdateClientCertificate (sslStream.InternalLocalCertificate);
else {
request.ServicePoint.UpdateClientCertificate (null);
sslStream.Dispose ();
sslStream = null;
}
}
@@ -154,5 +155,13 @@ namespace Mono.Net.Security
throw new PlatformNotSupportedException (EXCEPTION_MESSAGE);
#endif
}
public void Dispose ()
{
if (sslStream != null) {
sslStream.Dispose ();
sslStream = null;
}
}
}
}
@@ -508,9 +508,12 @@ namespace System.Diagnostics
int size = 0;
for (int i = 0; i < processes.Length; i++) {
var process = processes[i];
try {
if (String.Compare (processName, processes[i].ProcessName, true) == 0)
processes [size++] = processes[i];
if (String.Compare (processName, process.ProcessName, true) == 0)
processes [size++] = process;
else
process.Dispose();
} catch (SystemException) {
/* The process might exit between GetProcesses_internal and GetProcessById */
}
@@ -380,7 +380,12 @@ namespace System.IO.Compression
GC.SuppressFinalize (this);
io_buffer = null;
} else {
// When we are in the finalizer we don't want to access the underlying stream anymore
base_stream = Stream.Null;
}
if (z_stream != null) {
z_stream.Dispose();
}
@@ -273,7 +273,7 @@ namespace System.Net.Sockets
SetResults(SocketError.Success, bytesTransferred, flags);
current_socket = connectSocket;
OnCompleted (this);
Complete ();
}
internal void SetResults (SocketError socketError, int bytesTransferred, SocketFlags flags)
+47 -45
View File
@@ -434,7 +434,6 @@ namespace System.Net
}
public string Host {
get {
Uri uri = hostUri ?? Address;
return (hostUri == null || !hostHasPort) && Address.IsDefaultPort ?
@@ -828,7 +827,7 @@ namespace System.Net
WebOperation SendRequest (bool redirecting, BufferOffsetSize writeBuffer, CancellationToken cancellationToken)
{
lock (locker) {
WebConnection.Debug ($"HWR SEND REQUEST: Req={ID} requestSent={requestSent} redirecting={redirecting}");
WebConnection.Debug ($"HWR SEND REQUEST: Req={ID} requestSent={requestSent} actualUri={actualUri} redirecting={redirecting}");
WebOperation operation;
if (!redirecting) {
@@ -858,22 +857,21 @@ namespace System.Net
if (Aborted)
throw CreateRequestAbortedException ();
bool send = !(method == "GET" || method == "CONNECT" || method == "HEAD" ||
method == "TRACE");
bool send = !(method == "GET" || method == "CONNECT" || method == "HEAD" || method == "TRACE");
if (method == null || !send)
throw new ProtocolViolationException ("Cannot send data when method is: " + method);
throw new ProtocolViolationException (SR.net_nouploadonget);
if (contentLength == -1 && !sendChunked && !allowBuffering && KeepAlive)
throw new ProtocolViolationException ("Content-Length not set");
string transferEncoding = TransferEncoding;
if (!sendChunked && transferEncoding != null && transferEncoding.Trim () != "")
throw new ProtocolViolationException ("SendChunked should be true.");
throw new InvalidOperationException (SR.net_needchunked);
WebOperation operation;
lock (locker) {
if (getResponseCalled)
throw new InvalidOperationException ("The operation cannot be performed once the request has been submitted.");
throw new InvalidOperationException (SR.net_reqsubmitted);
operation = currentOperation;
if (operation == null) {
@@ -900,7 +898,7 @@ namespace System.Net
try {
return TaskToApm.End<Stream> (asyncResult);
} catch (Exception e) {
throw FlattenException (e);
throw GetWebException (e);
}
}
@@ -909,7 +907,7 @@ namespace System.Net
try {
return GetRequestStreamAsync ().Result;
} catch (Exception e) {
throw FlattenException (e);
throw GetWebException (e);
}
}
@@ -924,36 +922,19 @@ namespace System.Net
return RunWithTimeout (MyGetRequestStreamAsync);
}
internal static Task<T> RunWithTimeout<T> (
Func<CancellationToken, Task<T>> func, int timeout, Action abort)
{
// Call `func` here to propagate any potential exception that it
// might throw to our caller rather than returning a faulted task.
var cts = new CancellationTokenSource ();
var workerTask = func (cts.Token);
return RunWithTimeoutWorker (workerTask, timeout, abort, cts);
}
internal static Task<T> RunWithTimeout<T> (
Func<CancellationToken, Task<T>> func, int timeout, Action abort,
CancellationToken cancellationToken)
Func<bool> aborted, CancellationToken cancellationToken)
{
var cts = CancellationTokenSource.CreateLinkedTokenSource (cancellationToken);
return RunWithTimeout (func, timeout, abort, cts);
}
static Task<T> RunWithTimeout<T> (
Func<CancellationToken, Task<T>> func, int timeout, Action abort,
CancellationTokenSource cts)
{
// Call `func` here to propagate any potential exception that it
// might throw to our caller rather than returning a faulted task.
var workerTask = func (cts.Token);
return RunWithTimeoutWorker (workerTask, timeout, abort, cts);
return RunWithTimeoutWorker (workerTask, timeout, abort, aborted, cts);
}
static async Task<T> RunWithTimeoutWorker<T> (
Task<T> workerTask, int timeout, Action abort,
Task<T> workerTask, int timeout, Action abort, Func<bool> aborted,
CancellationTokenSource cts)
{
try {
@@ -965,9 +946,14 @@ namespace System.Net
} catch {
// Ignore; we report the timeout.
}
#pragma warning disable 4014
// Make sure the workerTask's Exception is actually observed.
// Fixes https://github.com/mono/mono/issues/10488.
workerTask.ContinueWith (t => t.Exception?.GetHashCode (), TaskContinuationOptions.OnlyOnFaulted);
#pragma warning restore 4014
throw new WebException (SR.net_timeout, WebExceptionStatus.Timeout);
} catch (Exception ex) {
throw FlattenException (ex);
throw GetWebException (ex, aborted ());
} finally {
cts.Dispose ();
}
@@ -975,7 +961,11 @@ namespace System.Net
Task<T> RunWithTimeout<T> (Func<CancellationToken, Task<T>> func)
{
return RunWithTimeout (func, timeout, Abort);
// Call `func` here to propagate any potential exception that it
// might throw to our caller rather than returning a faulted task.
var cts = new CancellationTokenSource ();
var workerTask = func (cts.Token);
return RunWithTimeoutWorker (workerTask, timeout, Abort, () => Aborted, cts);
}
async Task<HttpWebResponse> MyGetResponseAsync (CancellationToken cancellationToken)
@@ -983,13 +973,6 @@ namespace System.Net
if (Aborted)
throw CreateRequestAbortedException ();
if (method == null)
throw new ProtocolViolationException ("Method is null.");
string transferEncoding = TransferEncoding;
if (!sendChunked && transferEncoding != null && transferEncoding.Trim () != "")
throw new ProtocolViolationException ("SendChunked should be true.");
var completion = new WebCompletionSource ();
WebOperation operation;
lock (locker) {
@@ -1025,14 +1008,14 @@ namespace System.Net
try {
cancellationToken.ThrowIfCancellationRequested ();
WebConnection.Debug ($"HWR GET RESPONSE LOOP: Req={ID} {auth_state.NtlmAuthState}");
WebConnection.Debug ($"HWR GET RESPONSE LOOP: Req={ID} Op={operation?.ID} {auth_state.NtlmAuthState}");
writeStream = await operation.GetRequestStreamInternal ();
await writeStream.WriteRequestAsync (cancellationToken).ConfigureAwait (false);
stream = await operation.GetResponseStream ();
WebConnection.Debug ($"HWR RESPONSE LOOP #0: Req={ID} - {stream?.Headers != null}");
WebConnection.Debug ($"HWR RESPONSE LOOP #0: Req={ID} Op={operation?.ID} - {stream?.Headers != null}");
(response, redirect, mustReadAll, writeBuffer, ntlm) = await GetResponseFromData (
stream, cancellationToken).ConfigureAwait (false);
@@ -1040,7 +1023,7 @@ namespace System.Net
throwMe = GetWebException (e);
}
WebConnection.Debug ($"HWR GET RESPONSE LOOP #1: Req={ID} - redirect={redirect} mustReadAll={mustReadAll} writeBuffer={writeBuffer != null} ntlm={ntlm != null} - {throwMe != null}");
WebConnection.Debug ($"HWR GET RESPONSE LOOP #1: Req={ID} Op={operation?.ID} - redirect={redirect} mustReadAll={mustReadAll} writeBuffer={writeBuffer != null} ntlm={ntlm != null} - {throwMe != null}");
lock (locker) {
if (throwMe != null) {
@@ -1163,13 +1146,18 @@ namespace System.Net
}
WebException GetWebException (Exception e)
{
return GetWebException (e, Aborted);
}
static WebException GetWebException (Exception e, bool aborted)
{
e = FlattenException (e);
if (e is WebException wexc) {
if (!Aborted || wexc.Status == WebExceptionStatus.RequestCanceled || wexc.Status == WebExceptionStatus.Timeout)
if (!aborted || wexc.Status == WebExceptionStatus.RequestCanceled || wexc.Status == WebExceptionStatus.Timeout)
return wexc;
}
if (Aborted || e is OperationCanceledException || e is ObjectDisposedException)
if (aborted || e is OperationCanceledException || e is ObjectDisposedException)
return CreateRequestAbortedException ();
return new WebException (e.Message, e, WebExceptionStatus.UnknownError, null);
}
@@ -1184,6 +1172,20 @@ namespace System.Net
if (Aborted)
throw CreateRequestAbortedException ();
string transferEncoding = TransferEncoding;
if (!sendChunked && transferEncoding != null && transferEncoding.Trim () != "") {
/*
* The only way we could get here without already catching this in the
* `TransferEncoding` property settor is via HttpClient, which does not
* do strict checking on all headers.
*
* We can remove this check again after switching to the CoreFX version
* of HttpClient.
*
*/
throw new InvalidOperationException (SR.net_needchunked);
}
return TaskToApm.Begin (RunWithTimeout (MyGetResponseAsync), callback, state);
}
@@ -1195,7 +1197,7 @@ namespace System.Net
try {
return TaskToApm.End<HttpWebResponse> (asyncResult);
} catch (Exception e) {
throw FlattenException (e);
throw GetWebException (e);
}
}
@@ -1213,7 +1215,7 @@ namespace System.Net
try {
return GetResponseAsync ().Result;
} catch (Exception e) {
throw FlattenException (e);
throw GetWebException (e);
}
}
@@ -161,7 +161,7 @@ namespace System.Net
}
}
Debug ($"MAIN LOOP #1: operations={operationArray.Length} idle={idleArray.Length} finalCleanup={finalCleanup}");
Debug ($"MAIN LOOP #1: operations={operationArray.Length} idle={idleArray.Length} maxIdleTime={maxIdleTime} finalCleanup={finalCleanup}");
var ret = await Task.WhenAny (taskList).ConfigureAwait (false);
@@ -340,10 +340,8 @@ namespace System.Net
// Is there anything in the queue?
var next = group.GetNextOperation ();
if (next == null) {
Debug ($"{me} no pending operations.");
if (next == null)
return false;
}
Debug ($"{me} found pending operation Op={next.ID}");
@@ -598,9 +596,9 @@ namespace System.Net
public (WebConnection connection, bool created) CreateOrReuseConnection (WebOperation operation, bool force)
{
Scheduler.Debug ($"CREATE OR REUSE: group={ID} OP={operation.ID} force={force}");
Scheduler.Debug ($"CREATE OR REUSE: group={ID} Op={operation.ID} force={force}");
var connection = FindIdleConnection (operation);
Scheduler.Debug ($"CREATE OR REUSE #1: group={ID} OP={operation.ID} force={force} - connection={connection?.ID}");
Scheduler.Debug ($"CREATE OR REUSE #1: group={ID} Op={operation.ID} force={force} - connection={connection?.ID}");
if (connection != null)
return (connection, false);
@@ -405,6 +405,7 @@ namespace System.Net
void CloseSocket ()
{
lock (this) {
Debug ($"WC CLOSE SOCKET: Cnc={ID} NS={networkStream} TLS={monoTlsStream}");
if (networkStream != null) {
try {
networkStream.Dispose ();
@@ -412,6 +413,13 @@ namespace System.Net
networkStream = null;
}
if (monoTlsStream != null) {
try {
monoTlsStream.Dispose ();
} catch { }
monoTlsStream = null;
}
if (socket != null) {
try {
socket.Dispose ();
+1 -1
View File
@@ -41,7 +41,7 @@ namespace System.Net
}
#if MONO_WEB_DEBUG
internal string ME => $"WRS({GetType ().Name}:Op={operation.ID})";
internal string ME => $"WRS({GetType ().Name}:Op={Operation.ID})";
#else
internal string ME => null;
#endif
@@ -181,7 +181,7 @@ namespace System.Net
() => {
Operation.Abort ();
innerStream.Dispose ();
}, cancellationToken);
}, () => Operation.Aborted, cancellationToken);
}
bool CheckAuthHeader (string headerName)
@@ -530,7 +530,7 @@ namespace System.Net
else
StatusDescription = string.Empty;
if (pos >= buffer.Size)
if (pos >= buffer.Offset)
return true;
}
@@ -59,6 +59,8 @@ namespace System.Security.Cryptography.X509Certificates
public abstract bool Build (X509Certificate2 certificate);
public abstract void AddStatus (X509ChainStatusFlags errorCode);
public abstract void Reset ();
public void Dispose ()
@@ -110,6 +110,10 @@ namespace System.Security.Cryptography.X509Certificates {
// methods
public override void AddStatus (X509ChainStatusFlags error)
{
}
[MonoTODO ("Not totally RFC3280 compliant, but neither is MS implementation...")]
public override bool Build (X509Certificate2 certificate)
{
@@ -1096,13 +1096,14 @@ namespace MonoTests.System.ComponentModel
}
[Test]
#if FULL_AOT_RUNTIME
[Ignore ("https://github.com/mono/mono/issues/8407")]
#endif
public void TestCreateDesigner ()
{
IDesigner des = TypeDescriptor.CreateDesigner (com, typeof(int));
#if MOBILE
Assert.IsNull (des, "#1"); // We exclude DesignerAttribute on BCL types
#else
Assert.IsTrue (des is MyDesigner, "#1");
#endif
des = TypeDescriptor.CreateDesigner (com, typeof(string));
Assert.IsNull (des, "#2");
@@ -1132,31 +1133,37 @@ namespace MonoTests.System.ComponentModel
}
[Test]
#if FULL_AOT_RUNTIME
[Ignore ("https://github.com/mono/mono/issues/8407")]
#endif
public void TestGetAttributes ()
{
AttributeCollection col = TypeDescriptor.GetAttributes (typeof(MyComponent));
Assert.IsNotNull (col [typeof (DescriptionAttribute)], "#A1");
#if !MOBILE
Assert.IsNotNull (col [typeof (DesignerAttribute)], "#A2");
#endif
Assert.IsNull (col [typeof (EditorAttribute)], "#A3");
col = TypeDescriptor.GetAttributes (com);
Assert.IsNotNull (col [typeof (DescriptionAttribute)], "#B1");
#if !MOBILE
Assert.IsNotNull (col [typeof (DesignerAttribute)], "#B2");
#endif
Assert.IsNull (col [typeof (EditorAttribute)], "#B3");
col = TypeDescriptor.GetAttributes (sitedcom);
Assert.IsNotNull (col [typeof (DescriptionAttribute)], "#C1");
#if !MOBILE
Assert.IsNotNull (col [typeof (DesignerAttribute)], "#C2");
#endif
Assert.IsNotNull (col [typeof (EditorAttribute)], "#C3");
col = TypeDescriptor.GetAttributes (nfscom);
Assert.IsNotNull (col [typeof (DescriptionAttribute)], "#D1");
#if !MOBILE
Assert.IsNotNull (col [typeof (DesignerAttribute)], "#D2");
#endif
Assert.IsNull (col [typeof (EditorAttribute)], "#D3");
#if !MOBILE
col = TypeDescriptor.GetAttributes (typeof (MyDerivedComponent));
Assert.IsNotNull (col [typeof (DesignerAttribute)], "#E1");
Assert.IsNotNull (col [typeof (DescriptionAttribute)], "#E2");
@@ -1177,6 +1184,7 @@ namespace MonoTests.System.ComponentModel
// Shows that attributes are retrieved from the current type, the base types
// and the implemented by the type interfaces.
Assert.AreEqual (3, TypeDescriptor.GetAttributes (typeof (TestDerivedClass)).Count, "#F1");
#endif
}
[Test]
@@ -0,0 +1,15 @@
../../../external/corefx/src/System.CodeDom/tests/CodeCollections/*.cs
../../../external/corefx/src/System.CodeDom/tests/CodeExpressions/*.cs
../../../external/corefx/src/System.CodeDom/tests/CodeObjects/*.cs
../../../external/corefx/src/System.CodeDom/tests/CodeStatements/*.cs
../../../external/corefx/src/System.CodeDom/tests/CodeTypeMembers/*.cs
../../../external/corefx/src/System.CodeDom/tests/Compiler/*.cs
../../../external/corefx/src/System.CodeDom/tests/Other/*.cs
../../../external/corefx/src/System.CodeDom/tests/Microsoft/CSharp/*.cs
../../../external/corefx/src/System.CodeDom/tests/Microsoft/VisualBasic/*.cs
../../../external/corefx/src/System.CodeDom/tests/*.cs
../../../external/corefx/src/System.Net.Security/tests/UnitTests/Fakes/*.cs
../../../external/corefx/src/System.Text.RegularExpressions/tests/*.cs
@@ -724,7 +724,7 @@
</type>
<!-- domain.c: mono_defaults.mono_method_message_class -->
<type fullname="System.Runtime.Remoting.Messaging.MonoMethodMessage" preserve="fields" feature="remoting" >
<type fullname="System.Runtime.Remoting.Messaging.MonoMethodMessage" preserve="fields">
<!-- object.c: mono_message_init -->
<method name="InitMessage" />
</type>
+1 -1
View File
@@ -101,7 +101,7 @@ ifdef MONO_FEATURE_APPLE_X509
LIB_MCS_FLAGS += -d:MONO_FEATURE_APPLE_X509
endif
COREFX_FLAGS := -d:FEATURE_PORTABLE_SPAN
COREFX_FLAGS := -d:BIT64
WARNING_ABOUT_DISABLED_WARNING=1635
LOCAL_MCS_FLAGS = -unsafe -nostdlib -nowarn:612,618,3001,3002,3003,$(WARNING_ABOUT_DISABLED_WARNING) -d:INSIDE_CORLIB,MONO_CULTURE_DATA -d:LIBC $(REFERENCE_SOURCES_FLAGS) $(COREFX_FLAGS)
+128 -5
View File
@@ -63,7 +63,7 @@ namespace Mono {
// Should not be removed intended for external use
// Safe to be called using reflection
// Format is undefined only for use as a string for reporting
// Format is undefined only for use as a string for
[MethodImplAttribute (MethodImplOptions.InternalCall)]
#if MOBILE || XAMMAC_4_5
public
@@ -81,28 +81,151 @@ namespace Mono {
return true;
}
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern string ExceptionToState_internal (Exception exc, out ulong portable_hash, out ulong unportable_hash);
static Tuple<String, ulong, ulong>
ExceptionToState (Exception exc)
{
ulong portable_hash;
ulong unportable_hash;
string payload_str = ExceptionToState_internal (exc, out portable_hash, out unportable_hash);
return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
}
#if !MOBILE
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern void DisableMicrosoftTelemetry (IntPtr appBundleID, IntPtr appSignature, IntPtr appVersion, IntPtr merpGUIPath);
static extern void DisableMicrosoftTelemetry ();
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern void EnableMicrosoftTelemetry_internal (IntPtr appBundleID, IntPtr appSignature, IntPtr appVersion, IntPtr merpGUIPath);
static extern void EnableMicrosoftTelemetry_internal (IntPtr appBundleID, IntPtr appSignature, IntPtr appVersion, IntPtr merpGUIPath, IntPtr eventType, IntPtr appPath, IntPtr configDir);
static void EnableMicrosoftTelemetry (string appBundleID_str, string appSignature_str, string appVersion_str, string merpGUIPath_str)
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern void SendMicrosoftTelemetry_internal (IntPtr payload, ulong portable_hash, ulong unportable_hash);
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern void WriteStateToFile_internal (IntPtr payload, ulong portable_hash, ulong unportable_hash);
static void
WriteStateToFile (Exception exc)
{
ulong portable_hash;
ulong unportable_hash;
string payload_str = ExceptionToState_internal (exc, out portable_hash, out unportable_hash);
using (var payload_chars = RuntimeMarshal.MarshalString (payload_str))
{
WriteStateToFile_internal (payload_chars.Value, portable_hash, unportable_hash);
}
}
static void SendMicrosoftTelemetry (string payload_str, ulong portable_hash, ulong unportable_hash)
{
if (RuntimeInformation.IsOSPlatform (OSPlatform.OSX)) {
using (var payload_chars = RuntimeMarshal.MarshalString (payload_str))
{
SendMicrosoftTelemetry_internal (payload_chars.Value, portable_hash, unportable_hash);
}
} else {
throw new PlatformNotSupportedException("Merp support is currently only supported on OSX.");
}
}
// Usage:
//
// catch (Exception exc) {
// var monoType = Type.GetType ("Mono.Runtime", false);
// var m = monoType.GetMethod("SendExceptionToTelemetry", BindingFlags.NonPublic | BindingFlags.Static);
// m.Invoke(null, new object[] { exc });
// }
static void SendExceptionToTelemetry (Exception exc)
{
ulong portable_hash;
ulong unportable_hash;
string payload_str = ExceptionToState_internal (exc, out portable_hash, out unportable_hash);
SendMicrosoftTelemetry (payload_str, portable_hash, unportable_hash);
}
// All must be set except for configDir_str
static void EnableMicrosoftTelemetry (string appBundleID_str, string appSignature_str, string appVersion_str, string merpGUIPath_str, string eventType_str, string appPath_str)
{
if (RuntimeInformation.IsOSPlatform (OSPlatform.OSX)) {
using (var appBundleID_chars = RuntimeMarshal.MarshalString (appBundleID_str))
using (var appSignature_chars = RuntimeMarshal.MarshalString (appSignature_str))
using (var appVersion_chars = RuntimeMarshal.MarshalString (appVersion_str))
using (var merpGUIPath_chars = RuntimeMarshal.MarshalString (merpGUIPath_str))
using (var eventType_chars = RuntimeMarshal.MarshalString (eventType_str))
using (var appPath_chars = RuntimeMarshal.MarshalString (appPath_str))
{
EnableMicrosoftTelemetry_internal (appBundleID_chars.Value, appSignature_chars.Value, appVersion_chars.Value, merpGUIPath_chars.Value);
EnableMicrosoftTelemetry_internal (appBundleID_chars.Value, appSignature_chars.Value, appVersion_chars.Value, merpGUIPath_chars.Value, eventType_chars.Value, appPath_chars.Value, IntPtr.Zero);
}
} else {
throw new PlatformNotSupportedException("Merp support is currently only supported on OSX.");
}
}
#endif
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern string DumpStateSingle_internal (out ulong portable_hash, out ulong unportable_hash);
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern string DumpStateTotal_internal (out ulong portable_hash, out ulong unportable_hash);
static Tuple<String, ulong, ulong>
DumpStateSingle ()
{
ulong portable_hash;
ulong unportable_hash;
string payload_str = DumpStateSingle_internal (out portable_hash, out unportable_hash);
return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
}
static Tuple<String, ulong, ulong>
DumpStateTotal ()
{
ulong portable_hash;
ulong unportable_hash;
string payload_str = DumpStateTotal_internal (out portable_hash, out unportable_hash);
return new Tuple<String, ulong, ulong> (payload_str, portable_hash, unportable_hash);
}
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern void RegisterReportingForNativeLib_internal (IntPtr modulePathSuffix, IntPtr moduleName);
static void RegisterReportingForNativeLib (string modulePathSuffix_str, string moduleName_str)
{
using (var modulePathSuffix_chars = RuntimeMarshal.MarshalString (modulePathSuffix_str))
using (var moduleName_chars = RuntimeMarshal.MarshalString (moduleName_str))
{
RegisterReportingForNativeLib_internal (modulePathSuffix_chars.Value, moduleName_chars.Value);
}
}
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern void EnableCrashReportLog_internal (IntPtr directory);
static void EnableCrashReportLog (string directory_str)
{
using (var directory_chars = RuntimeMarshal.MarshalString (directory_str))
{
EnableCrashReportLog_internal (directory_chars.Value);
}
}
[MethodImplAttribute (MethodImplOptions.InternalCall)]
static extern int CheckCrashReportLog_internal (IntPtr directory, bool clear);
static int CheckCrashReportLog (string directory_str, bool clear)
{
using (var directory_chars = RuntimeMarshal.MarshalString (directory_str))
{
return CheckCrashReportLog_internal (directory_chars.Value, clear);
}
}
}
}
@@ -1,3 +1,12 @@
#if BIT64
using nuint = System.UInt64;
#else
using nuint = System.UInt32;
#endif
using System.Runtime.CompilerServices;
using System.Runtime;
namespace System
{
partial class Buffer
@@ -213,7 +222,28 @@ namespace System
internal static unsafe void Memmove (byte *dest, byte *src, uint len)
{
if (((nuint)dest - (nuint)src < len) || ((nuint)src - (nuint)dest < len))
goto PInvoke;
Memcpy (dest, src, (int) len);
return;
PInvoke:
RuntimeImports.Memmove(dest, src, len);
}
internal static void Memmove<T>(ref T destination, ref T source, nuint elementCount)
{
if (!RuntimeHelpers.IsReferenceOrContainsReferences<T>()) {
unsafe {
fixed (byte* pDestination = &Unsafe.As<T, byte>(ref destination), pSource = &Unsafe.As<T, byte>(ref source))
Memmove(pDestination, pSource, (uint)elementCount * (uint)Unsafe.SizeOf<T>());
}
} else {
unsafe {
fixed (byte* pDestination = &Unsafe.As<T, byte>(ref destination), pSource = &Unsafe.As<T, byte>(ref source))
RuntimeImports.Memmove_wbarrier(pDestination, pSource, (uint)elementCount, typeof(T).TypeHandle.Value);
}
}
}
}
}
@@ -810,5 +810,20 @@ namespace System
return false;
}
}
[System.Runtime.InteropServices.ComVisible(true)]
[Pure]
public override bool IsSubclassOf(Type type)
{
if ((object)type == null)
throw new ArgumentNullException("type");
Contract.EndContractBlock();
RuntimeType rtType = type as RuntimeType;
if (rtType == null)
return false;
return RuntimeTypeHandle.IsSubclassOf (this, rtType);
}
}
}
+21 -10
View File
@@ -34,11 +34,19 @@
//
//
#if BIT64
using nuint = System.UInt64;
#else
using nuint = System.UInt32;
#endif
using System.Runtime.CompilerServices;
using System.Text;
using System.Globalization;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Diagnostics.Private;
namespace System
{
@@ -51,15 +59,6 @@ namespace System
public static readonly String Empty;
public unsafe static implicit operator ReadOnlySpan<char> (String value)
{
if (value == null)
return default;
fixed (void* start = &value._firstChar)
return new ReadOnlySpan<char> (start, value.Length);
}
internal unsafe int IndexOfUnchecked (string value, int startIndex, int count)
{
int valueLen = value.Length;
@@ -87,6 +86,13 @@ namespace System
return -1;
}
[CLSCompliant(false)]
public static String Concat(Object arg0, Object arg1, Object arg2, Object arg3, __arglist)
{
// Added to maintain backward compatibility, see https://github.com/mono/mono/issues/9996
throw new PlatformNotSupportedException();
}
internal unsafe int IndexOfUncheckedIgnoreCase (string value, int startIndex, int count)
{
int valueLen = value.Length;
@@ -202,7 +208,12 @@ namespace System
if (this.Length < value.Length || _firstChar != value._firstChar)
return false;
return value.Length == 1 ? true : StartsWithOrdinalHelper (this, value);
return value.Length == 1 ?
true :
SpanHelpers.SequenceEqual (
ref Unsafe.As<char, byte> (ref this.GetRawStringData ()),
ref Unsafe.As<char, byte> (ref value.GetRawStringData ()),
((nuint)value.Length) * 2);
}
[MethodImplAttribute (MethodImplOptions.InternalCall)]
+43 -1
View File
@@ -1,4 +1,5 @@
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace System.Globalization
{
@@ -198,7 +199,7 @@ namespace System.Globalization
return c;
}
static unsafe int InternalCompareStringOrdinalIgnoreCase (String strA, int indexA, String strB, int indexB, int lenA, int lenB)
internal static unsafe int InternalCompareStringOrdinalIgnoreCase (String strA, int indexA, String strB, int indexB, int lenA, int lenB)
{
if (strA == null) {
return strB == null ? 0 : -1;
@@ -229,6 +230,47 @@ namespace System.Globalization
return lengthA - lengthB;
}
}
internal void ToLowerAsciiInvariant (ReadOnlySpan<char> source, Span<char> destination)
{
for (int i = 0; i < source.Length; i++)
{
destination [i] = ToLowerAsciiInvariant (source [i]);
}
}
internal void ToUpperAsciiInvariant (ReadOnlySpan<char> source, Span<char> destination)
{
for (int i = 0; i < source.Length; i++)
{
destination [i] = ToUpperAsciiInvariant (source[i]);
}
}
internal unsafe void ChangeCase (ReadOnlySpan<char> source, Span<char> destination, bool toUpper)
{
if (source.IsEmpty)
return;
var ti = CultureInfo.CurrentCulture.TextInfo;
fixed (char* pSource = &MemoryMarshal.GetReference (source))
fixed (char* pResult = &MemoryMarshal.GetReference (destination)) {
int length = 0;
char* a = pSource, b = pResult;
if (toUpper) {
while (length < source.Length) {
*b++ = ti.ToUpper (*a++);
length++;
}
} else {
while (length < source.Length) {
*b++ = ti.ToLower (*a++);
length++;
}
}
}
}
}
static class TextInfoToUpperData
@@ -172,7 +172,7 @@ namespace System.Reflection.Emit {
CreateDynMethod ();
deleg = Delegate.CreateDelegate (delegateType, this);
deleg = Delegate.CreateDelegate (delegateType, null, this);
return deleg;
}
+1 -1
View File
@@ -213,7 +213,7 @@ namespace System.Reflection {
private static bool filter_by_type_name (Type m, object filterCriteria) {
string s = (string)filterCriteria;
if (s.Length > 0 && s [s.Length - 1] == '*')
return m.Name.StartsWithOrdinalUnchecked (s.Substring (0, s.Length - 1));
return m.Name.StartsWith (s.Substring (0, s.Length - 1), StringComparison.Ordinal);
return m.Name == s;
}
@@ -31,6 +31,8 @@
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
namespace System.Runtime.CompilerServices
{
@@ -375,11 +377,109 @@ namespace System.Runtime.CompilerServices
}
}
// IEnumerable implementation was copied from CoreCLR
IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator ()
{
throw new NotImplementedException ();
lock (_lock)
{
return size == 0 ?
((IEnumerable<KeyValuePair<TKey, TValue>>)Array.Empty<KeyValuePair<TKey, TValue>>()).GetEnumerator() :
new Enumerator(this);
}
}
IEnumerator IEnumerable.GetEnumerator () => ((IEnumerable<KeyValuePair<TKey, TValue>>)this).GetEnumerator ();
/// <summary>Provides an enumerator for the table.</summary>
private sealed class Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>
{
// The enumerator would ideally hold a reference to the Container and the end index within that
// container. However, the safety of the CWT depends on the only reference to the Container being
// from the CWT itself; the Container then employs a two-phase finalization scheme, where the first
// phase nulls out that parent CWT's reference, guaranteeing that the second time it's finalized there
// can be no other existing references to it in use that would allow for concurrent usage of the
// native handles with finalization. We would break that if we allowed this Enumerator to hold a
// reference to the Container. Instead, the Enumerator holds a reference to the CWT rather than to
// the Container, and it maintains the CWT._activeEnumeratorRefCount field to track whether there
// are outstanding enumerators that have yet to be disposed/finalized. If there aren't any, the CWT
// behaves as it normally does. If there are, certain operations are affected, in particular resizes.
// Normally when the CWT is resized, it enumerates the contents of the table looking for indices that
// contain entries which have been collected or removed, and it frees those up, effectively moving
// down all subsequent entries in the container (not in the existing container, but in a replacement).
// This, however, would cause the enumerator's understanding of indices to break. So, as long as
// there is any outstanding enumerator, no compaction is performed.
private ConditionalWeakTable<TKey, TValue> _table; // parent table, set to null when disposed
private int _currentIndex = -1; // the current index into the container
private KeyValuePair<TKey, TValue> _current; // the current entry set by MoveNext and returned from Current
public Enumerator(ConditionalWeakTable<TKey, TValue> table)
{
// Store a reference to the parent table and increase its active enumerator count.
_table = table;
_currentIndex = -1;
}
~Enumerator() { Dispose(); }
public void Dispose()
{
// Use an interlocked operation to ensure that only one thread can get access to
// the _table for disposal and thus only decrement the ref count once.
ConditionalWeakTable<TKey, TValue> table = Interlocked.Exchange(ref _table, null);
if (table != null)
{
// Ensure we don't keep the last current alive unnecessarily
_current = default;
// Finalization is purely to decrement the ref count. We can suppress it now.
GC.SuppressFinalize(this);
}
}
public bool MoveNext()
{
// Start by getting the current table. If it's already been disposed, it will be null.
ConditionalWeakTable<TKey, TValue> table = _table;
if (table != null)
{
// Once have the table, we need to lock to synchronize with other operations on
// the table, like adding.
lock (table._lock)
{
var tombstone = GC.EPHEMERON_TOMBSTONE;
while (_currentIndex < table.data.Length - 1)
{
_currentIndex++;
var currentDataItem = table.data[_currentIndex];
if (currentDataItem.key != null && currentDataItem.key != tombstone)
{
_current = new KeyValuePair<TKey, TValue>((TKey)currentDataItem.key, (TValue)currentDataItem.value);
return true;
}
}
}
}
// Nothing more to enumerate.
return false;
}
public KeyValuePair<TKey, TValue> Current
{
get
{
if (_currentIndex < 0)
{
ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumOpCantHappen();
}
return _current;
}
}
object IEnumerator.Current => Current;
public void Reset() { }
}
}
}
@@ -0,0 +1,40 @@
//
// PreserveDependencyAttribute.cs
//
// Authors:
// Marek Safar <[email protected]>
//
// Copyright (C) 2018 Microsoft Corporation
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
namespace System.Runtime.CompilerServices {
[AttributeUsage (AttributeTargets.Method | AttributeTargets.Constructor, AllowMultiple = true)]
/*public*/ sealed class PreserveDependencyAttribute : Attribute {
public PreserveDependencyAttribute (string metadataSignature)
{
}
public PreserveDependencyAttribute (string metadataSignature, string condition)
{
}
}
}
+15
View File
@@ -65,6 +65,21 @@ namespace System
return true;
}
// adapted to the Mono array layout
[StructLayout(LayoutKind.Sequential)]
private class RawData
{
public IntPtr Bounds;
public IntPtr Count;
public byte Data;
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal ref byte GetRawSzArrayData()
{
return ref Unsafe.As<RawData>(this).Data;
}
internal IEnumerator<T> InternalArray__IEnumerable_GetEnumerator<T> ()
{
if (Length == 0)
+2
View File
@@ -62,6 +62,8 @@ namespace System
private IntPtr delegate_trampoline;
private IntPtr extra_arg;
private IntPtr method_code;
private IntPtr interp_method;
private IntPtr interp_invoke_impl;
private MethodInfo method_info;
// Keep a ref of the MethodInfo passed to CreateDelegate.
@@ -250,5 +250,13 @@ namespace System
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern static IntPtr GetGenericParameterInfo (RuntimeType type);
internal static bool IsSubclassOf (RuntimeType childType, RuntimeType baseType)
{
return is_subclass_of (childType._impl.Value, baseType._impl.Value);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern static bool is_subclass_of (IntPtr childType, IntPtr baseType);
}
}
+1 -22
View File
@@ -173,7 +173,7 @@ namespace System {
offset++;
offset += ((int) number) * intOffset;
return GetInteger (buffer, offset);
return GetInt16 (buffer, offset);
}
public string Get (TermInfoStrings tstr)
@@ -222,27 +222,6 @@ namespace System {
return (short) (uno + dos * 256);
}
int GetInt32 (byte [] buffer, int offset)
{
int b1 = (int) buffer [offset];
int b2 = (int) buffer [offset + 1];
int b3 = (int) buffer [offset + 2];
int b4 = (int) buffer [offset + 3];
if (b1 == 255 && b2 == 255 && b3 == 255 && b4 == 255)
return -1;
return b1 + b2 << 8 + b3 << 16 + b4 << 24;
}
int GetInteger (byte [] buffer, int offset)
{
if (intOffset == 2)
return GetInt16 (buffer, offset);
else
// intOffset == 4
return GetInt32 (buffer, offset);
}
string GetString (byte [] buffer, int offset)
{
int length = 0;
@@ -740,6 +740,55 @@ namespace MonoTests.System.Reflection.Emit
Assert.AreEqual (typeof (TypedRefTarget), TypedReference.GetTargetType (tr));
}
#endif
static Action GenerateProblematicMethod (bool add_extra, bool mismatch = false, bool use_vts = false)
{
Type this_type = typeof(object);
Type bound_type = typeof(object);
if (mismatch) {
this_type = typeof (string);
bound_type = typeof (DynamicMethodTest);
} else if (use_vts) {
this_type = typeof (int);
bound_type = typeof (long);
}
Type[] args;
if (add_extra)
args = new[] { this_type };
else
args = new Type [0];
var mb = new DynamicMethod("Peek", null, args, bound_type, true);
var il = mb.GetILGenerator ();
il.Emit(OpCodes.Ret);
return (Action) mb.CreateDelegate(typeof(Action));
}
[Test]
public void ExtraArgGetsIgnored ()
{
GenerateProblematicMethod (true) ();
}
[Test]
public void ExactNumberOfArgsWork ()
{
GenerateProblematicMethod (false) ();
}
[Test]
public void ExtraArgWithMismatchedTypes ()
{
GenerateProblematicMethod (true, mismatch: true) ();
}
[Test]
[ExpectedException (typeof (ArgumentException))]
public void ExtraArgWithValueType ()
{
GenerateProblematicMethod (true, use_vts: true) ();
}
}
}
@@ -1287,6 +1287,22 @@ namespace MonoTests.System.Reflection
} catch (NotImplementedException){
}
}
[Test]
[ExpectedException (typeof (ArgumentException))]
public void LoadFileRelativeThrows ()
{
Assembly.LoadFile (Path.Combine ("non-existent", "relative", "path.dll"));
}
[Test]
[ExpectedException (typeof (FileNotFoundException))]
public void LoadFileAbsoluteNotFoundThrows ()
{
// have to use GetFullPath so we get C:\... on Windows
var abspath = Path.GetFullPath (Path.Combine ("non-existent", "absolute", "path.dll"));
Assembly.LoadFile (abspath);
}
}
public class TestDefinedTypes
@@ -31,6 +31,7 @@
using NUnit.Framework;
using System;
using System.Linq;
using System.Threading;
using System.Reflection;
#if !MONOTOUCH && !FULL_AOT_RUNTIME
@@ -890,6 +891,60 @@ namespace MonoTests.System.Reflection
}
}
static void EnsureMethodExists (Type type, string name, params Type[] parameterTypes)
{
var method = type.GetTypeInfo ().GetDeclaredMethods (name)
.SingleOrDefault (m => m.GetParameters ().Select (p => p.ParameterType).SequenceEqual (parameterTypes));
Assert.IsNotNull (method, $"{type}.{name}");
}
public void EnsureEntityFrameworkMethodsExist ()
{
// EntityFramework6 relies on the following methods
// see https://github.com/aspnet/EntityFramework6/blob/master/src/EntityFramework/Core/Objects/ELinq/MethodCallTranslator.cs#L846
// also https://github.com/mono/mono/pull/10452
EnsureMethodExists (typeof (Math), "Ceiling", typeof (decimal));
EnsureMethodExists (typeof (Math), "Ceiling", typeof (double));
EnsureMethodExists (typeof (Math), "Floor", typeof (decimal));
EnsureMethodExists (typeof (Math), "Floor", typeof (double));
EnsureMethodExists (typeof (Math), "Round", typeof (decimal));
EnsureMethodExists (typeof (Math), "Round", typeof (double));
EnsureMethodExists (typeof (Math), "Round", typeof (decimal), typeof (int));
EnsureMethodExists (typeof (Math), "Round", typeof (double), typeof (int));
EnsureMethodExists (typeof (Decimal), "Floor", typeof (decimal));
EnsureMethodExists (typeof (Decimal), "Ceiling", typeof (decimal));
EnsureMethodExists (typeof (Decimal), "Round", typeof (decimal));
EnsureMethodExists (typeof (Decimal), "Round", typeof (decimal), typeof (int));
EnsureMethodExists (typeof (String), "Replace", typeof (String), typeof (String));
EnsureMethodExists (typeof (String), "ToLower");
EnsureMethodExists (typeof (String), "ToUpper");
EnsureMethodExists (typeof (String), "Trim");
EnsureMethodExists (typeof (Math), "Truncate", typeof (decimal));
EnsureMethodExists (typeof (Math), "Truncate", typeof (double));
EnsureMethodExists (typeof (Math), "Pow", typeof (double), typeof (double));
EnsureMethodExists (typeof (Guid), "NewGuid");
EnsureMethodExists (typeof (String), "Contains", typeof (string));
EnsureMethodExists (typeof (String), "IndexOf", typeof (string));
EnsureMethodExists (typeof (String), "StartsWith", typeof (string));
EnsureMethodExists (typeof (String), "EndsWith", typeof (string));
EnsureMethodExists (typeof (String), "Substring", typeof (int));
EnsureMethodExists (typeof (String), "Substring", typeof (int), typeof (int));
EnsureMethodExists (typeof (String), "Remove", typeof (int));
EnsureMethodExists (typeof (String), "Remove", typeof (int), typeof (int));
EnsureMethodExists (typeof (String), "IsNullOrEmpty", typeof (string));
EnsureMethodExists (typeof (String), "Concat", typeof (string), typeof (string));
EnsureMethodExists (typeof (String), "Concat", typeof (string), typeof (string), typeof (string));
EnsureMethodExists (typeof (String), "Concat", typeof (string), typeof (string), typeof (string), typeof (string));
EnsureMethodExists (typeof (String), "Concat", typeof (object), typeof (object));
EnsureMethodExists (typeof (String), "Concat", typeof (object), typeof (object), typeof (object));
EnsureMethodExists (typeof (String), "Concat", typeof (object), typeof (object), typeof (object), typeof (object));
EnsureMethodExists (typeof (String), "Concat", typeof (object[]));
EnsureMethodExists (typeof (String), "Concat", typeof (string[]));
EnsureMethodExists (typeof (String), "Trim", typeof (Char[]));
EnsureMethodExists (typeof (String), "TrimStart", typeof (Char[]));
EnsureMethodExists (typeof (String), "TrimEnd", typeof (Char[]));
}
[Test]
public void TestLocalVariableTypes ()
{
@@ -324,10 +324,14 @@ public class ModuleTest
Type[] t;
t = m.FindTypes (Module.FilterTypeName, "*");
Assert.AreNotEqual (0, t.Length, "#A0");
t = m.FindTypes (Module.FilterTypeName, "FindTypesTest*");
Assert.AreEqual (2, t.Length, "#A1");
Assert.AreEqual ("FindTypesTestFirstClass", t [0].Name, "#A2");
Assert.AreEqual ("FindTypesTestSecondClass", t [1].Name, "#A3");
t = m.FindTypes (Module.FilterTypeNameIgnoreCase, "*");
Assert.AreNotEqual (0, t.Length, "#B0");
t = m.FindTypes (Module.FilterTypeNameIgnoreCase, "findtypestest*");
Assert.AreEqual (2, t.Length, "#B1");
Assert.AreEqual ("FindTypesTestFirstClass", t [0].Name, "#B2");
@@ -484,6 +484,8 @@ namespace MonoTests.System.Reflection
}
[Test] // https://github.com/mono/mono/issues/8312
// The linker removes the SkipWhile methods
[Category ("MobileNotWorking")]
public void ParameterInfoToStringForQueryableSkipWhile ()
{
var sb = new StringBuilder ();
@@ -29,6 +29,7 @@
using NUnit.Framework;
using System;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
@@ -486,6 +487,20 @@ namespace MonoTests.System.Runtime.CompilerServices {
Assert.IsTrue (table.Remove (key), "#2-" + i + "-k-" + key);
}
}
[Test]
public void ConditionalWeakTableEnumerable()
{
var cwt = new ConditionalWeakTable<string, string>();
Assert.AreEqual(0, cwt.ToArray().Length);
cwt.Add("test1", "foo1");
cwt.Add("test2", "foo2");
Assert.AreEqual(2, cwt.ToArray().Length);
cwt.Remove("test1");
Assert.AreEqual(1, cwt.ToArray().Length);
cwt.Remove("test2");
Assert.AreEqual(0, cwt.ToArray().Length);
}
}
}
@@ -120,6 +120,13 @@ namespace MonoTests.System.Runtime.InteropServices
Assert.IsTrue (size == 4 || size == 8);
}
[Test]
public unsafe void Sizeof_Void ()
{
int size = Marshal.SizeOf (typeof (void));
Assert.AreEqual (1, size);
}
[Test]
public void PtrToStringWithNull ()
{
@@ -36,6 +36,7 @@ namespace MonoTests.System.Runtime.Remoting
appDomainObject.Init(crossDomainSerializedObject);
}
#if !MOBILE
[Test]
public void Bug46473 () // concurrent serialization/deserialization
{
@@ -48,13 +49,9 @@ namespace MonoTests.System.Runtime.Remoting
var name = "AppDomainWithCall" + i;
tasks [i] = Task.Factory.StartNew(() => AppDomainWithRemotingSerialization(assembly, name));
}
try {
Task.WaitAll (tasks);
} catch (AggregateException e) {
success = false;
Console.WriteLine ($"{e}, {e.InnerException}");
}
Assert.IsTrue (success, "Bug46473 (exception during remoting call)");
Assert.IsTrue (Task.WaitAll (tasks, 5000));
}
#endif
}
}
@@ -77,12 +77,12 @@ namespace MonoTests.System.Threading.Tasks
{
ParallelTestHelper.Repeat (delegate {
var t = CreateNestedFuture(10);
var t2 = CreateNestedFuture(100);
var t3 = CreateNestedFuture(100);
var t2 = CreateNestedFuture(20);
var t3 = CreateNestedFuture(30);
Assert.AreEqual (11, t.Result);
Assert.AreEqual (101, t2.Result);
Assert.AreEqual (101, t3.Result);
Assert.AreEqual (21, t2.Result);
Assert.AreEqual (31, t3.Result);
}, 50);
}
@@ -4916,7 +4916,6 @@ namespace MonoTests.System {
}
[Test]
[Category ("NotWorkingRuntimeInterpreter")]
public void ChangeTypeFromInvalidDouble ()
{
// types which should generate OverflowException from double.NaN, etc.
@@ -925,7 +925,6 @@ namespace MonoTests.System
}
[Test]
[Category ("NotWorkingRuntimeInterpreter")]
#if MONOTOUCH || FULL_AOT_RUNTIME
[Category ("NotWorking")] // #10539
#endif
@@ -1102,7 +1101,6 @@ namespace MonoTests.System
event Action bar_handler;
[Test]
[Category ("NotWorkingRuntimeInterpreter")]
[ExpectedException (typeof (ArgumentException))] // #635349, #605936
public void NewDelegateClosedOverNullReferenceInstanceMethod ()
{
@@ -1283,7 +1281,6 @@ namespace MonoTests.System
}
#if !MONOTOUCH && !FULL_AOT_RUNTIME
[Test]
[Category ("NotWorkingRuntimeInterpreter")]
public void CreateDelegateWithLdFtnAndAbstractMethod ()
{
AssemblyName assemblyName = new AssemblyName ();
@@ -231,6 +231,13 @@ namespace MonoTests.System
Environment.SetEnvironmentVariable ("A3", "\0");
Assert.IsNull (Environment.GetEnvironmentVariables ()["A3"]);
}
[Test] // github issue #9839
public void MachineNameIsNotFullyQualifiedDomainName ()
{
Assert.IsNotNull (Environment.MachineName);
Assert.AreEqual (-1, Environment.MachineName.IndexOf("."));
}
#endif
}
}
@@ -15,6 +15,9 @@ using System.Runtime.Serialization;
using NUnit.Framework;
using System.Threading.Tasks;
using System.Reflection;
namespace MonoTests.System
{
[TestFixture]
@@ -400,6 +403,218 @@ namespace MonoTests.System
Assert.IsNull (a.InnerException.Source);
}
#if !MOBILE
// Ensure that we can convert a stacktrace to a
// telemetry message
//
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void StacktraceToState ()
{
try {
throw new Exception ("#0");
} catch (Exception exc) {
var monoType = Type.GetType ("Mono.Runtime", false);
var convert = monoType.GetMethod("ExceptionToState", BindingFlags.NonPublic | BindingFlags.Static);
object [] convert_params = new object[] {exc};
var output = (Tuple<String, ulong, ulong>) convert.Invoke(null, convert_params);
var dump = output.Item1;
var portable_hash = output.Item2;
var unportable_hash = output.Item3;
Assert.IsTrue (portable_hash != 0, "#1");
Assert.IsTrue (unportable_hash != 0, "#2");
Assert.IsTrue (dump.Length > 0, "#3");
// Console.WriteLine (dump);
// dump should look something like:
// {
// "protocol_version" : "0.0.1",
// "configuration" : {
// "version" : "5.19.0 (managed_telemetry_pipeline/d342c73e320 Wed Aug 15 14:40:40 EDT 2018)",
// "tlc" : "normal",
// "sigsgev" : "altstack",
// "notifications" : "kqueue",
// "architecture" : "amd64",
// "disabled_features" : "none",
// "smallconfig" : "disabled",
// "bigarrays" : "disabled",
// "softdebug" : "enabled",
// "interpreter" : "enabled",
// "llvm_support" : "disabled",
// "suspend" : "hybrid"
// },
// "memory" : {
// "Resident Size" : "40693760",
// "Virtual Size" : "4521312256",
// "minor_gc_time" : "216992",
// "major_gc_time" : "0",
// "minor_gc_count" : "6",
// "major_gc_count" : "0",
// "major_gc_time_concurrent" : "0"
// },
// "threads" : [
// {
// "is_managed" : false,
// "managed_thread_ptr" : "0x0",
// "thread_info_addr" : "0x0",
// "native_thread_id" : "0x0",
// "managed_exception_type" : "System.Exception",
// "managed_frames" : [
// {
// "is_managed" : "true",
// "guid" : "43A03618-E657-44B0-B9FA-F63314A3C1B2",
// "token" : "0x60008da",
// "native_offset" : "0xb2",
// "il_offset" : "0x00000"
// }
// ]
// }
// ]
// }
}
}
void DumpSingle ()
{
var monoType = Type.GetType ("Mono.Runtime", false);
var convert = monoType.GetMethod("DumpStateSingle", BindingFlags.NonPublic | BindingFlags.Static);
var output = (Tuple<String, ulong, ulong>) convert.Invoke(null, Array.Empty<object> ());
var dump = output.Item1;
var portable_hash = output.Item2;
var unportable_hash = output.Item3;
Assert.IsTrue (portable_hash != 0, "#1");
Assert.IsTrue (unportable_hash != 0, "#2");
Assert.IsTrue (dump.Length > 0, "#3");
}
void DumpTotal ()
{
var monoType = Type.GetType ("Mono.Runtime", false);
var convert = monoType.GetMethod("DumpStateTotal", BindingFlags.NonPublic | BindingFlags.Static);
var output = (Tuple<String, ulong, ulong>) convert.Invoke(null, Array.Empty<object> ());
var dump = output.Item1;
var portable_hash = output.Item2;
var unportable_hash = output.Item3;
Assert.IsTrue (portable_hash != 0, "#1");
Assert.IsTrue (unportable_hash != 0, "#2");
Assert.IsTrue (dump.Length > 0, "#3");
}
void DumpLogSet ()
{
var monoType = Type.GetType ("Mono.Runtime", false);
var convert = monoType.GetMethod("EnableCrashReportLog", BindingFlags.NonPublic | BindingFlags.Static);
convert.Invoke(null, new object[] { "./" });
}
void DumpLogUnset ()
{
var monoType = Type.GetType ("Mono.Runtime", false);
var convert = monoType.GetMethod("EnableCrashReportLog", BindingFlags.NonPublic | BindingFlags.Static);
convert.Invoke(null, new object[] { null });
}
void DumpLogCheck ()
{
var monoType = Type.GetType ("Mono.Runtime", false);
var convert = monoType.GetMethod("CheckCrashReportLog", BindingFlags.NonPublic | BindingFlags.Static);
var result = (int) convert.Invoke(null, new object[] { "./", true });
var monoSummaryDone = 8;
Assert.AreEqual (monoSummaryDone, result, "#DLC1");
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallTotalLogged ()
{
DumpLogSet ();
DumpTotal ();
DumpLogUnset ();
DumpLogCheck ();
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallSingleOnce ()
{
DumpSingle ();
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallSingleConcurrent ()
{
// checks that self-dumping works in parallel, locklessly
int amt = 20;
var tasks = new Task [amt];
for (int i=0; i < amt; i++)
tasks [i] = Task.Run(() => DumpSingle ());
Task.WaitAll (tasks);
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallSingleAsync ()
{
// checks that dumping works in an async context
var t = Task.Run(() => DumpSingle ());
t.Wait ();
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallTotalOnce ()
{
DumpTotal ();
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallTotalRepeated ()
{
// checks that the state doesn't get broken with repeated use
DumpTotal ();
DumpTotal ();
DumpTotal ();
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallTotalAsync ()
{
// checks that dumping works in an async context
var t = Task.Run(() => DumpTotal ());
t.Wait ();
}
[Test]
[Category("NotOnWindows")]
[Category("NotOnLinux")]
public void DumpICallTotalConcurrent ()
{
int amt = 3;
var tasks = new Task [amt];
for (int i=0; i < amt; i++)
tasks [i] = Task.Run(() => DumpTotal ());
Task.WaitAll (tasks);
}
#endif
[Test]
public void StackTrace ()
{
+36 -4
View File
@@ -36,6 +36,39 @@ namespace MonoTests.System {
[TestFixture]
public class GCTest {
static class FinalizerHelpers {
private static IntPtr aptr;
private static unsafe void NoPinActionHelper (int depth, Action act)
{
// Avoid tail calls
int* values = stackalloc int [20];
aptr = new IntPtr (values);
if (depth <= 0) {
//
// When the action is called, this new thread might have not allocated
// anything yet in the nursery. This means that the address of the first
// object that would be allocated would be at the start of the tlab and
// implicitly the end of the previous tlab (address which can be in use
// when allocating on another thread, at checking if an object fits in
// this other tlab). We allocate a new dummy object to avoid this type
// of false pinning for most common cases.
//
new object ();
act ();
} else {
NoPinActionHelper (depth - 1, act);
}
}
public static void PerformNoPinAction (Action act)
{
Thread thr = new Thread (() => NoPinActionHelper (128, act));
thr.Start ();
thr.Join ();
}
}
class MyFinalizeObject
{
@@ -59,10 +92,9 @@ namespace MonoTests.System {
[Category ("NotWorkingRuntimeInterpreter")]
public void ReRegisterForFinalizeTest ()
{
var thread = new Thread (Run_ReRegisterForFinalizeTest);
thread.Start ();
thread.Join ();
FinalizerHelpers.PerformNoPinAction (delegate () {
Run_ReRegisterForFinalizeTest ();
});
var t = Task.Factory.StartNew (() => {
do {
GC.Collect ();
+5
View File
@@ -445,6 +445,11 @@ namespace MonoTests.System
Assert.IsNull (paramType.BaseType, "#02-b");
Assert.IsTrue (paramType.IsSubclassOf (typeof (Object)), "#03");
Assert.IsFalse (paramType.IsSubclassOf (paramType), "#04");
// IsSubclassOf is not reflexive
Assert.IsFalse (typeof (string).IsSubclassOf (typeof (string)), "#05");
Assert.IsFalse (typeof (int).IsSubclassOf (typeof (int)), "#06");
Assert.IsFalse (typeof (object).IsSubclassOf (typeof (object)), "#07");
}
[Test]
+30 -6
View File
@@ -90,22 +90,44 @@ namespace System.Globalization
unsafe int IndexOfCore (ReadOnlySpan<char> source, ReadOnlySpan<char> target, CompareOptions options, int* matchLengthPtr)
{
throw new NotImplementedException ();
// TODO: optimize
var s = new string (source);
var t = new string (target);
return IndexOfCore (s, t, 0, s.Length, options, matchLengthPtr);
}
int IndexOfOrdinalCore (ReadOnlySpan<char> source, ReadOnlySpan<char> value, bool ignoreCase)
{
throw new NotImplementedException ();
// TODO: optimize
var s = new string (source);
var v = new string (value);
if (!ignoreCase)
return s.IndexOfUnchecked (v, 0, s.Length);
return s.IndexOfUncheckedIgnoreCase (v, 0, s.Length);
}
int CompareString (ReadOnlySpan<char> string1, string string2, CompareOptions options)
{
throw new NotImplementedException ();
// TODO: optimize
var s1 = new string (string1);
return internal_compare_switch (s1, 0, s1.Length, string2, 0, string2.Length, options);
}
int CompareString (ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, CompareOptions options)
{
throw new NotImplementedException ();
// TODO: optimize
var s1 = new string (string1);
var s2 = new string (string2);
return internal_compare_switch (s1, 0, s1.Length, new string (s2), 0, s2.Length, options);
}
unsafe static bool IsSortable (char *text, int length)
@@ -137,7 +159,8 @@ namespace System.Globalization
bool StartsWith (ReadOnlySpan<char> source, ReadOnlySpan<char> prefix, CompareOptions options)
{
throw new NotImplementedException ();
// TODO: optimize
return StartsWith (new string (source), new string (prefix), options);
}
bool EndsWith (string source, string suffix, CompareOptions options)
@@ -153,7 +176,8 @@ namespace System.Globalization
bool EndsWith (ReadOnlySpan<char> source, ReadOnlySpan<char> suffix, CompareOptions options)
{
throw new NotImplementedException ();
// TODO: optimize
return EndsWith (new string (source), new string (suffix), options);
}
internal int GetHashCodeOfStringCore (string source, CompareOptions options)
@@ -1,26 +0,0 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Diagnostics;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using Internal.Runtime.CompilerServices;
namespace System
{
partial class MemoryExtensions
{
// copied from corefx - MemoryExtensions.Fast.cs
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static bool EqualsOrdinal(this ReadOnlySpan<char> span, ReadOnlySpan<char> value)
{
if (span.Length != value.Length)
return false;
if (value.Length == 0) // span.Length == value.Length == 0
return true;
return span.SequenceEqual(value); //TODO: Optimize - https://github.com/dotnet/corefx/issues/27487
}
}
}
-30
View File
@@ -1,30 +0,0 @@
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System.Buffers;
using System.Runtime.CompilerServices;
using System.Collections.Generic;
using Internal.Runtime.CompilerServices;
namespace System.Runtime.InteropServices
{
partial class MemoryMarshal
{
/// <summary>
/// Returns a reference to the 0th element of the Span. If the Span is empty, returns a reference to fake non-null pointer. Such a reference can be used
/// for pinning but must never be dereferenced. This is useful for interop with methods that do not accept null pointers for zero-sized buffers.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe ref T GetNonNullPinnableReference<T>(Span<T> span) =>
ref (span.Length != 0) ? ref span.DangerousGetPinnableReference() : ref Unsafe.AsRef<T>((void*)1);
/// <summary>
/// Returns a reference to the 0th element of the ReadOnlySpan. If the ReadOnlySpan is empty, returns a reference to fake non-null pointer. Such a reference
/// can be used for pinning but must never be dereferenced. This is useful for interop with methods that do not accept null pointers for zero-sized buffers.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
internal static unsafe ref T GetNonNullPinnableReference<T>(ReadOnlySpan<T> span) =>
ref (span.Length != 0) ? ref span.DangerousGetPinnableReference() : ref Unsafe.AsRef<T>((void*)1);
}
}
+62
View File
@@ -0,0 +1,62 @@
//
// RuntimeImports.cs
//
// Authors:
// Marek Safar <[email protected]>
//
// Copyright (C) 2018 Microsoft Corporation
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System.Runtime.CompilerServices;
#if BIT64
using nuint = System.UInt64;
#else
using nuint = System.UInt32;
#endif
namespace System.Runtime
{
static class RuntimeImports
{
internal static unsafe void RhZeroMemory (ref byte b, nuint byteLength)
{
fixed (byte* bytePointer = &b) {
ZeroMemory (bytePointer, (uint)byteLength);
}
}
internal static unsafe void RhZeroMemory (IntPtr p, UIntPtr byteLength)
{
ZeroMemory ((void*)p, (uint) byteLength);
}
[MethodImpl (MethodImplOptions.InternalCall)]
static extern unsafe void ZeroMemory (void* p, uint byteLength);
[MethodImpl (MethodImplOptions.InternalCall)]
internal static extern unsafe void Memmove (byte* dest, byte* src, uint len);
[MethodImpl (MethodImplOptions.InternalCall)]
internal static extern unsafe void Memmove_wbarrier (byte* dest, byte* src, uint len, IntPtr type_handle);
}
}
+31 -27
View File
@@ -4,7 +4,7 @@
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">net_4_x</Platform>
<ProjectGuid>{4627BDAB-CA24-40D0-A627-01692BA51B44}</ProjectGuid>
<ProjectGuid>{D3EB59BC-59F1-4D6F-9FCD-6B2FF977C066}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>612,618,3001,3002,3003,1635,1699</NoWarn>
<LangVersion>latest</LangVersion>
@@ -28,82 +28,82 @@
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_CONSOLE;MONO_FEATURE_APPLETLS;FEATURE_CRYPTO_CONFIGURABLE</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_CONSOLE;MONO_FEATURE_APPLETLS;FEATURE_CRYPTO_CONFIGURABLE</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monodroid' ">
<OutputPath>./../../class/lib/monodroid</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-monodroid</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;MONODROID;ANDROID;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch' ">
<OutputPath>./../../class/lib/monotouch</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-monotouch</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_runtime' ">
<OutputPath>./../../class/lib/monotouch_runtime</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-monotouch_runtime</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch' ">
<OutputPath>./../../class/lib/monotouch_watch</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-monotouch_watch</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_APPLE_X509</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_APPLE_X509</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_watch_runtime' ">
<OutputPath>./../../class/lib/monotouch_watch_runtime</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-monotouch_watch_runtime</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLE_X509</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FEATURE_NO_BSD_SOCKETS;MONOTOUCH_WATCH;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLE_X509</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv' ">
<OutputPath>./../../class/lib/monotouch_tv</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-monotouch_tv</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;FULL_AOT_RUNTIME;MONOTOUCH_TV;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'monotouch_tv_runtime' ">
<OutputPath>./../../class/lib/monotouch_tv_runtime</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-monotouch_tv_runtime</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;MONOTOUCH_TV;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MOBILE;MOBILE_LEGACY;MONO;MONOTOUCH;DISABLE_REMOTING;DISABLE_COM;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;MONOTOUCH_TV;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<OutputPath>./../../class/lib/testing_aot_hybrid</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-testing_aot_hybrid</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_LEGACY;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'testing_aot_full' ">
<OutputPath>./../../class/lib/testing_aot_full</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-testing_aot_full</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'winaot' ">
<OutputPath>./../../class/lib/winaot</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-winaot</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_CONSOLE</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;DISABLE_REMOTING;DISABLE_COM;WIN_PLATFORM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_CONSOLE</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac' ">
<OutputPath>./../../class/lib/xammac</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-xammac</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_DYNAMIC;XAMMAC;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;XAMARIN_MODERN;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'xammac_net_4_5' ">
<OutputPath>./../../class/lib/xammac_net_4_5-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-xammac_net_4_5-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_CONSOLE;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_4_0;NET_4_5;NET_4_6;MONO;FEATURE_INTERCEPTABLE_THREADPOOL_CALLBACK;NO_SYSTEM_DRAWING_DEPENDENCY;NO_WINFORMS_DEPENDENCY;NO_SYSTEM_WEB_DEPENDENCY;XAMMAC_4_5;XAMARIN_MODERN;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_MACL;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;MONO_FEATURE_CONSOLE;MONO_FEATURE_APPLETLS;ONLY_APPLETLS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'orbis' ">
<OutputPath>./../../class/lib/orbis</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-orbis</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;ORBIS;DISABLE_REMOTING;DISABLE_COM;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'unreal' ">
<OutputPath>./../../class/lib/unreal</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-unreal</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;MOBILE;MOBILE_DYNAMIC;NET_3_5;NET_4_0;NET_4_5;MONO;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;FEATURE_REMOTING;MONO_COM;FEATURE_COMINTEROP;FEATURE_ROLE_BASED_SECURITY;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'wasm' ">
<OutputPath>./../../class/lib/wasm</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-wasm</IntermediateOutputPath>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;FEATURE_PORTABLE_SPAN;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
<DefineConstants>INSIDE_CORLIB;MONO_CULTURE_DATA;LIBC;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS;BIT64;NET_1_1;NET_2_0;NET_2_1;NET_3_5;NET_4_0;NET_4_5;MONO;MOBILE;MOBILE_LEGACY;FULL_AOT_DESKTOP;FULL_AOT_RUNTIME;WASM;DISABLE_REMOTING;DISABLE_COM;FEATURE_NO_BSD_SOCKETS;FEATURE_PAL;GENERICS_WORK;FEATURE_LIST_PREDICATES;FEATURE_SERIALIZATION;FEATURE_ENCODINGNLS;FEATURE_ASCII;FEATURE_LATIN1;FEATURE_UTF7;FEATURE_UTF32;MONO_HYBRID_ENCODING_SUPPORT;FEATURE_ASYNC_IO;NEW_EXPERIMENTAL_ASYNC_IO;FEATURE_UTF32;FEATURE_EXCEPTIONDISPATCHINFO;FEATURE_CORRUPTING_EXCEPTIONS;FEATURE_EXCEPTION_NOTIFICATIONS;FEATURE_STRONGNAME_MIGRATION;FEATURE_USE_LCID;FEATURE_FUSION;FEATURE_CRYPTO;FEATURE_X509_SECURESTRINGS;FEATURE_SYNCHRONIZATIONCONTEXT;FEATURE_SYNCHRONIZATIONCONTEXT_WAIT;HAS_CORLIB_CONTRACTS;MONO_FEATURE_THREAD_ABORT;MONO_FEATURE_THREAD_SUSPEND_RESUME;MONO_FEATURE_MULTIPLE_APPDOMAINS</DefineConstants>
</PropertyGroup>
<!-- @ALL_PROFILE_PROPERTIES@ -->
<PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
@@ -119,6 +119,7 @@
</PropertyGroup>
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\ArraySegment.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Buffers\ArrayPool.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Buffers\ArrayPoolEventSource.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Buffers\ConfigurableArrayPool.cs" />
@@ -174,12 +175,14 @@
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Memory.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\MemoryDebugView.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\MemoryExtensions.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\MemoryExtensions.Fast.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Numerics\ConstantHelper.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Numerics\Register.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Numerics\Vector.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Numerics\Vector_Operations.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\ReadOnlyMemory.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\ReadOnlySpan.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\ReadOnlySpan.Fast.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Reflection\BindingFlags.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Runtime\CompilerServices\AccessedThroughPropertyAttribute.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Runtime\CompilerServices\AsyncMethodBuilderAttribute.cs" />
@@ -223,11 +226,17 @@
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Runtime\CompilerServices\UnsafeValueTypeAttribute.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Runtime\CompilerServices\ValueTaskAwaiter.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Runtime\InteropServices\MemoryMarshal.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Runtime\InteropServices\MemoryMarshal.Fast.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Span.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Span.Fast.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\SpanDebugView.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\SpanHelpers.BinarySearch.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\SpanHelpers.Byte.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\SpanHelpers.Char.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\SpanHelpers.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\SpanHelpers.T.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\String.Comparison.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\String.Manipulation.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\String.Searching.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\StringSplitOptions.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\Text\ASCIIEncoding.cs" />
@@ -358,17 +367,13 @@
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpan.LittleG.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Buffers\Text\Utf8Parser\Utf8Parser.TimeSpanSplitter.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\MemoryExtensions.Portable.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Number\Decimal.DecCalc.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Number\Number.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Number\Number.FormatAndParse.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Number\Number.NumberBuffer.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Pinnable.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\ReadOnlySpan.Portable.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Runtime\InteropServices\MemoryMarshal.Portable.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Runtime\InteropServices\SequenceMarshal.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\SequencePosition.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\Span.Portable.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\SpanHelpers.cs" />
<Compile Include="..\..\..\external\corefx\src\System.Memory\src\System\ThrowHelper.cs" />
<Compile Include="..\..\..\external\corefx\src\System.ObjectModel\src\System\Collections\Generic\DebugView.cs" />
@@ -390,17 +395,15 @@
<Compile Include="..\..\..\external\corert\src\Common\src\System\Collections\Generic\LowLevelList.cs" />
<Compile Include="..\..\..\external\corert\src\Common\src\System\Numerics\Hashing\HashHelpers.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\shared\System\Diagnostics\Debug.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\shared\System\String.Manipulation.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\shared\System\StringSpanHelpers.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\Internal\Runtime\Augments\AsyncCausalityTracer.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\Internal\Runtime\Augments\TaskTraceCallbacks.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\Internal\Threading\Tasks\Tracing\TaskTrace.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\Array.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\ByReference.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\Globalization\GlobalizationMode.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\Runtime\CompilerServices\ReflectionBlockedAttribute.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\Runtime\CompilerServices\TaskAwaiter.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\String.Comparison.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\String.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\Threading\CancellationTokenRegistration.cs" />
<Compile Include="..\..\..\external\corert\src\System.Private.CoreLib\src\System\Threading\LockHolder.cs" />
@@ -485,7 +488,6 @@
<Compile Include="..\referencesource\mscorlib\system\argumentnullexception.cs" />
<Compile Include="..\referencesource\mscorlib\system\argumentoutofrangeexception.cs" />
<Compile Include="..\referencesource\mscorlib\system\arithmeticexception.cs" />
<Compile Include="..\referencesource\mscorlib\system\arraysegment.cs" />
<Compile Include="..\referencesource\mscorlib\system\arraytypemismatchexception.cs" />
<Compile Include="..\referencesource\mscorlib\system\asynccallback.cs" />
<Compile Include="..\referencesource\mscorlib\system\attribute.cs" />
@@ -1040,8 +1042,7 @@
<Compile Include="corefx\AwaitTaskContinuation.cs" />
<Compile Include="corefx\CompareInfo.cs" />
<Compile Include="corefx\GlobalizationMode.cs" />
<Compile Include="corefx\MemoryExtensions.cs" />
<Compile Include="corefx\MemoryMarshal.cs" />
<Compile Include="corefx\RuntimeImports.cs" />
<Compile Include="corefx\SR.cs" />
<Compile Include="corefx\SynchronizationContext.cs" />
<Compile Include="corert\AddrofIntrinsics.cs" />
@@ -1288,6 +1289,7 @@
<Compile Include="System.Reflection\StrongNameKeyPair.cs" />
<Compile Include="System.Resources\Win32Resources.cs" />
<Compile Include="System.Runtime.CompilerServices\ConditionalWeakTable.cs" />
<Compile Include="System.Runtime.CompilerServices\PreserveDependencyAttribute.cs" />
<Compile Include="System.Runtime.CompilerServices\RuntimeHelpers.cs" />
<Compile Include="System.Runtime.CompilerServices\Unsafe.cs" />
<Compile Include="System.Runtime.Hosting\ActivationArguments.cs" />
@@ -2116,6 +2118,8 @@
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'winaot' ">
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\Interop\Windows\BCrypt\Interop.BCryptGenRandom.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\Interop\Windows\BCrypt\Interop.BCryptGenRandom.GetRandomBytes.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\Interop\Windows\BCrypt\Interop.NTSTATUS.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\Interop\Windows\Interop.Libraries.cs" />
<Compile Include="..\..\..\external\corefx\src\Common\src\CoreLib\System\HashCode.cs" />
<Compile Include="..\..\..\external\corert\src\Common\src\Interop\Windows\Interop.Libraries.cs" />
+12 -14
View File
@@ -330,6 +330,7 @@ System.Runtime/MemoryFailPoint.cs
System.Runtime.CompilerServices/ConditionalWeakTable.cs
System.Runtime.CompilerServices/RuntimeHelpers.cs
System.Runtime.CompilerServices/Unsafe.cs
System.Runtime.CompilerServices/PreserveDependencyAttribute.cs
System.Runtime.Hosting/ActivationArguments.cs
System.Runtime.Hosting/ApplicationActivator.cs
System.Runtime.InteropServices/_Activator.cs
@@ -901,7 +902,6 @@ ReferenceSources/Type.cs
../referencesource/mscorlib/system/argumentnullexception.cs
../referencesource/mscorlib/system/argumentoutofrangeexception.cs
../referencesource/mscorlib/system/arithmeticexception.cs
../referencesource/mscorlib/system/arraysegment.cs
../referencesource/mscorlib/system/arraytypemismatchexception.cs
../referencesource/mscorlib/system/asynccallback.cs
../referencesource/mscorlib/system/attribute.cs
@@ -1541,9 +1541,8 @@ corefx/AwaitTaskContinuation.cs
corefx/SynchronizationContext.cs
corefx/SR.cs
corefx/CompareInfo.cs
corefx/MemoryExtensions.cs
corefx/GlobalizationMode.cs
corefx/MemoryMarshal.cs
corefx/RuntimeImports.cs
corert/DependencyReductionRootAttribute.cs
corert/AddrofIntrinsics.cs
@@ -1562,17 +1561,15 @@ corert/RuntimeAugments.cs
../../../external/corert/src/Common/src/System/Numerics/Hashing/HashHelpers.cs
../../../external/corert/src/System.Private.CoreLib/shared/System/String.Manipulation.cs
../../../external/corert/src/System.Private.CoreLib/shared/System/StringSpanHelpers.cs
../../../external/corert/src/System.Private.CoreLib/shared/System/Diagnostics/Debug.cs
../../../external/corert/src/System.Private.CoreLib/src/Internal/Runtime/Augments/AsyncCausalityTracer.cs
../../../external/corert/src/System.Private.CoreLib/src/Internal/Runtime/Augments/TaskTraceCallbacks.cs
../../../external/corert/src/System.Private.CoreLib/src/System/Array.cs
../../../external/corert/src/System.Private.CoreLib/src/System/ByReference.cs
# TODO: Should all come from shared
../../../external/corert/src/System.Private.CoreLib/src/System/String.cs
../../../external/corert/src/System.Private.CoreLib/src/System/String.Comparison.cs
../../../external/corert/src/System.Private.CoreLib/src/System/Collections/Generic/ArraySortHelper.cs
@@ -1610,6 +1607,7 @@ corert/RuntimeAugments.cs
../../../external/corefx/src/System.ObjectModel/src/System/Collections/ObjectModel/KeyedCollection.cs
../../../external/corefx/src/System.ObjectModel/src/System/Collections/ObjectModel/ReadOnlyDictionary.cs
../../../external/corefx/src/Common/src/CoreLib/System/ArraySegment.cs
../../../external/corefx/src/Common/src/CoreLib/System/Gen2GcCallback.cs
../../../external/corefx/src/Common/src/CoreLib/System/HResults.cs
../../../external/corefx/src/Common/src/CoreLib/System/MathF.cs
@@ -1617,14 +1615,16 @@ corert/RuntimeAugments.cs
../../../external/corefx/src/Common/src/CoreLib/System/Memory.cs
../../../external/corefx/src/Common/src/CoreLib/System/MemoryDebugView.cs
../../../external/corefx/src/Common/src/CoreLib/System/MemoryExtensions.cs
../../../external/corefx/src/Common/src/CoreLib/System/MemoryExtensions.Fast.cs
../../../external/corefx/src/Common/src/CoreLib/System/ReadOnlyMemory.cs
../../../external/corefx/src/Common/src/CoreLib/System/ReadOnlySpan.cs
../../../external/corefx/src/Common/src/CoreLib/System/ReadOnlySpan.Fast.cs
../../../external/corefx/src/Common/src/CoreLib/System/Span.cs
../../../external/corefx/src/Common/src/CoreLib/System/Span.Fast.cs
../../../external/corefx/src/Common/src/CoreLib/System/SpanDebugView.cs
#../../../external/corefx/src/Common/src/CoreLib/System/SpanHelpers.cs
../../../external/corefx/src/Common/src/CoreLib/System/SpanHelpers.BinarySearch.cs
../../../external/corefx/src/Common/src/CoreLib/System/SpanHelpers.Byte.cs
../../../external/corefx/src/Common/src/CoreLib/System/SpanHelpers.T.cs
../../../external/corefx/src/Common/src/CoreLib/System/SpanHelpers*.cs
../../../external/corefx/src/Common/src/CoreLib/System/String.Comparison.cs
../../../external/corefx/src/Common/src/CoreLib/System/String.Manipulation.cs
../../../external/corefx/src/Common/src/CoreLib/System/String.Searching.cs
../../../external/corefx/src/Common/src/CoreLib/System/StringSplitOptions.cs
../../../external/corefx/src/Common/src/CoreLib/System/Tuple.cs
@@ -1721,6 +1721,7 @@ corert/RuntimeAugments.cs
../../../external/corefx/src/Common/src/CoreLib/System/Runtime/InteropServices/MemoryMarshal.cs
../../../external/corefx/src/Common/src/CoreLib/System/Runtime/InteropServices/MemoryMarshal.Fast.cs
../../../external/corefx/src/Common/src/CoreLib/System/Threading/Tasks/TaskCanceledException.cs
../../../external/corefx/src/Common/src/CoreLib/System/Threading/Tasks/TaskCompletionSource.cs
@@ -1748,15 +1749,12 @@ corert/RuntimeAugments.cs
../../../external/corefx/src/System.Collections.Concurrent/src/System/Collections/Concurrent/PartitionerStatic.cs
../../../external/corefx/src/System.Memory/src/System/Pinnable.cs
../../../external/corefx/src/System.Memory/src/System/MemoryExtensions.Portable.cs
../../../external/corefx/src/System.Memory/src/System/ReadOnlySpan.Portable.cs
../../../external/corefx/src/System.Memory/src/System/SequencePosition.cs
../../../external/corefx/src/System.Memory/src/System/SpanHelpers.cs
../../../external/corefx/src/System.Memory/src/System/Span.Portable.cs
../../../external/corefx/src/System.Memory/src/System/ThrowHelper.cs
../../../external/corefx/src/System.Memory/src/System/Buffers/*.cs
../../../external/corefx/src/System.Memory/src/System/Buffers/Binary/*.cs
../../../external/corefx/src/System.Memory/src/System/Runtime/InteropServices/*.cs
../../../external/corefx/src/System.Memory/src/System/Runtime/InteropServices/*.cs:MemoryMarshal.Portable.cs
../../../external/corefx/src/Common/src/CoreLib/System/Buffers/Text/FormattingHelpers.CountDigits.cs
../../../external/corefx/src/System.Memory/src/System/Buffers/StandardFormat.cs
+2 -2
View File
@@ -208,7 +208,7 @@
../../../external/corefx/src/Common/tests/System/EnumTypes.cs
../../../external/corefx/src/Common/tests/System/ObjectCloner.cs
../../../external/corefx/src/Common/tests/System/Diagnostics/DebuggerAttributes.cs
../../../external/corefx/src/System.Collections/tests/Generic/SortedSet/*.cs
../../../external/corefx/src/System.Collections/tests/Generic/SortedSet/*.cs:SortedSet.TreeSubSet.Tests.cs
../../../external/corefx/src/System.Collections/tests/Generic/HashSet/*.cs
../../../external/corefx/src/System.Collections/tests/Generic/Stack/*.cs
../../../external/corefx/src/System.Collections/tests/Generic/SortedList/*.cs
@@ -219,7 +219,7 @@
../../../external/corefx/src/System.Collections/tests/Generic/HashSet/*.cs
../../../external/corefx/src/System.Collections/tests/Generic/Dictionary/HashCollisionScenarios/*.cs
../../../external/corefx/src/System.Collections/tests/Generic/Dictionary/*.cs
../../../external/corefx/src/System.Collections/tests/Generic/Comparers/*.cs
../../../external/corefx/src/System.Collections/tests/Generic/Comparers/*.cs:EqualityComparer.Tests.cs
../../../external/corefx/src/System.Collections/tests/BitArray/*.cs:BitArray_GetSetTests.cs
../../../external/corefx/src/System.Collections/tests/*.cs
Loaded 100 of 304 files, more files were not shown because too many files have changed in this diff. Show more