Compare commits

..
2125 Commits
Author SHA1 Message Date
Marius UngureanuandMartin Baulig df99fccf69 Apply suggestions from code review
Co-Authored-By: Martin Baulig <[email protected]>
2019-05-31 12:08:46 +02:00
Marius Ungureanu 27554bf06b Plug leak of CustomAttribute initializer name
All the CustomAttribute initializer names (fields, property) except the last were leaked. Ensure all names are freed.

Fixes #14543
2019-05-31 12:08:46 +02:00
Vlad Brezae ddf393026a [marshal] Fix race between delegate marshaling and finalization
When passing a delegate to native code, we pass the delegate_trampoline which can be used to invoke the delegate from native code and we store this mapping (delegate_trampoline->delegate) in a hashtable so we can get a delegate for the delegate_trampoline, when marshalling the opposite way. If we are trying to marshal a ftnptr (for managed code) to a delegate and we don't find this mapping we can crash. This could happen if the finalization for some other delegate that uses the same ftnptr removes this entry from the table. We solve this by never freeing these entries. The first delegate-ftnptr pair will always be alive. This is easier, faster and potentially uses less memory than tracking in the hashtable every pair. There should be a small and limited set of methods marshalled to native.

Fixes https://github.com/mono/mono/issues/13231
2019-05-31 12:05:50 +02:00
Alexander Köplinger 4181954955 [bcl] Add nunit exclude categories for monotouch/monodroid profiles (#14695)
We didn't set all the categories that the products used in our profiles.

Now that the products can consume the exclude categories from mono we
need to unify the values.

Removed ValueAdd since it's not used anymore and combined MacNotWorking
into NotOnMac.

(cherry picked from commit f46191114b)
2019-05-29 17:00:41 +02:00
Alexander Köplinger 0ca2187eb3 [System] Fix MultiCastOptionTest on WatchOS
With https://github.com/mono/mono/commit/cf69b4725976e51416bfdff22f3e1834006af00a it started doing DNS lookups for localhost and we don't have sockets on the watch.

(cherry picked from commit 4fcbbd8fb7)
2019-05-29 16:45:47 +02:00
Alexander Köplinger 197461e034 [sdks] Only package android-sources on macOS
rsync might not be installed on other platforms and we only need android-sources in one sdks archive.

(cherry picked from commit edd6c013b0)
2019-05-29 00:30:56 +02:00
Alexander Köplinger 356964caf2 [sdks] Don't package android-sources on Windows
We don't need it there.

(cherry picked from commit a2f66ddca1)
2019-05-28 19:50:49 +02:00
Alexander Köplinger 271b64409d [sdks] Add linker sources to android sdks archive (#14686)
(cherry picked from commit c96878fb16)
2019-05-28 18:56:11 +02:00
Alexander Köplinger 1e2119b6df [bcl] Write newline-separated nunit/xunit excludes file for sdks archive (#14681)
During XI integration we noticed that just using the verbatim commandline
-exclude or -notrait is not ideal since XI uses the nunit/xunit APIs to
pass that information and not the command line parser.

Instead we now write the exclude categories/traits as a newline-separated file.

(cherry picked from commit 07c58ee2ed)
2019-05-28 18:51:43 +02:00
monojenkins da671d0b3c [2019-04] [mscorlib] Ensure monotouch[_runtime] API are identical (#14680)
* [mscorlib] Ensure monotouch[_runtime] API are identical

Ensure the API surface for `mscorlib.Core.dll` is identical between the
`monotouch` and `monotouch_runtime` (used for REPL and the interpreter).

This ensure code compiled against one will be fine when building against
the other (e.g. avoiding linker errors).

In practice this means:

1. Expose the API needed for `System.Reflection.Emit` in XI

	- throwing `PlatformNotSupportedException` **by default**; or
	- calling the mono runtime when the interpreter is enabled;

2. Do not expose additional, not supported, API (e.g. COM related)

	- `monotouch_runtime` configuration was built without `FULL_AOT_RUNTIME`
	  and that brings some other stuff that is not AOT related

Follow up to #14606

Existing diff

Removed methods:

```csharp
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes, Security.SecurityContextSource securityContextSource);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, bool isSynchronized, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions, bool isSynchronized);

[Obsolete ("Declarative security for assembly level is no longer enforced")]
public Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions, bool isSynchronized, System.Collections.Generic.IEnumerable<Reflection.Emit.CustomAttributeBuilder> assemblyAttributes);
```

Removed methods:

```csharp
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions);
public virtual Reflection.Emit.AssemblyBuilder DefineDynamicAssembly (Reflection.AssemblyName name, Reflection.Emit.AssemblyBuilderAccess access, string dir, Security.Policy.Evidence evidence, Security.PermissionSet requiredPermissions, Security.PermissionSet optionalPermissions, Security.PermissionSet refusedPermissions, bool isSynchronized);
```

Added constructor:

```csharp
public AssemblyBuilder ();
```

Removed properties:

```csharp
public override string CodeBase { get; }
public override System.Reflection.MethodInfo EntryPoint { get; }
public override string EscapedCodeBase { get; }
public override System.Security.Policy.Evidence Evidence { get; }
public override string FullName { get; }
public override bool GlobalAssemblyCache { get; }
public override string ImageRuntimeVersion { get; }
public override bool IsDynamic { get; }
public override string Location { get; }
public override System.Reflection.Module ManifestModule { get; }
public override bool ReflectionOnly { get; }
```

Removed methods:

```csharp
public void AddResourceFile (string name, string fileName);
public void AddResourceFile (string name, string fileName, System.Reflection.ResourceAttributes attribute);
public ModuleBuilder DefineDynamicModule (string name, bool emitSymbolInfo);
public ModuleBuilder DefineDynamicModule (string name, string fileName);
public ModuleBuilder DefineDynamicModule (string name, string fileName, bool emitSymbolInfo);
public System.Resources.IResourceWriter DefineResource (string name, string description, string fileName);
public System.Resources.IResourceWriter DefineResource (string name, string description, string fileName, System.Reflection.ResourceAttributes attribute);
public void DefineUnmanagedResource (byte[] resource);
public void DefineUnmanagedResource (string resourceFileName);
public void DefineVersionInfoResource ();
public void DefineVersionInfoResource (string product, string productVersion, string company, string copyright, string trademark);
public override bool Equals (object obj);
public override object[] GetCustomAttributes (bool inherit);
public override object[] GetCustomAttributes (System.Type attributeType, bool inherit);
public override System.Type[] GetExportedTypes ();
public override System.IO.FileStream GetFile (string name);
public override System.IO.FileStream[] GetFiles (bool getResourceModules);
public override int GetHashCode ();
public override System.Reflection.Module[] GetLoadedModules (bool getResourceModules);
public override System.Reflection.ManifestResourceInfo GetManifestResourceInfo (string resourceName);
public override string[] GetManifestResourceNames ();
public override System.IO.Stream GetManifestResourceStream (string name);
public override System.IO.Stream GetManifestResourceStream (System.Type type, string name);
public override System.Reflection.Module GetModule (string name);
public override System.Reflection.Module[] GetModules (bool getResourceModules);
public override System.Reflection.AssemblyName GetName (bool copiedName);
public override System.Reflection.AssemblyName[] GetReferencedAssemblies ();
public override System.Reflection.Assembly GetSatelliteAssembly (System.Globalization.CultureInfo culture);
public override System.Reflection.Assembly GetSatelliteAssembly (System.Globalization.CultureInfo culture, System.Version version);
public override System.Type GetType (string name, bool throwOnError, bool ignoreCase);
public override bool IsDefined (System.Type attributeType, bool inherit);
public void Save (string assemblyFileName);
public void Save (string assemblyFileName, System.Reflection.PortableExecutableKinds portableExecutableKind, System.Reflection.ImageFileMachine imageFileMachine);
public void SetEntryPoint (System.Reflection.MethodInfo entryMethod, PEFileKinds fileKind);
public override string ToString ();
```

Added constructor:

```csharp
public ConstructorBuilder ();
```

Removed properties:

```csharp
public override System.Reflection.CallingConventions CallingConvention { get; }
public override System.Reflection.Module Module { get; }

[Obsolete]
public System.Type ReturnType { get; }
```

Removed methods:

```csharp
public void AddDeclarativeSecurity (System.Security.Permissions.SecurityAction action, System.Security.PermissionSet pset);
public void SetSymCustomAttribute (string name, byte[] data);
public override string ToString ();
```

Removed property:

```csharp
public override System.Reflection.Module Module { get; }
```

Added property:

```csharp
public override System.Reflection.MethodImplAttributes MethodImplementationFlags { get; }
```

Removed methods:

```csharp
public override System.Delegate CreateDelegate (System.Type delegateType);
public override System.Delegate CreateDelegate (System.Type delegateType, object target);
public override string ToString ();
```

Added properties:

```csharp
public override bool IsByRefLike { get; }
public override bool IsSZArray { get; }
public override bool IsVariableBoundArray { get; }
```

Removed method:

```csharp
public override bool IsAssignableFrom (System.Reflection.TypeInfo typeInfo);
```

Added constructor:

```csharp
public EventBuilder ();
```

Removed properties:

```csharp
public override int MetadataToken { get; }
public override System.Reflection.Module Module { get; }
```

Removed method:

```csharp
[Obsolete ("An alternate API is available: Emit the MarshalAs custom attribute instead.")]
public void SetMarshal (UnmanagedMarshal unmanagedMarshal);
```

Added properties:

```csharp
public override bool IsByRefLike { get; }
public override bool IsConstructedGenericType { get; }
public override bool IsSZArray { get; }
public override bool IsTypeDefinition { get; }
public override bool IsVariableBoundArray { get; }
```

Removed methods:

```csharp
public override System.Type[] GetGenericParameterConstraints ();
public override bool IsAssignableFrom (System.Reflection.TypeInfo typeInfo);
public override bool IsInstanceOfType (object o);
```

Modified properties:

```diff
-public virtual int ILOffset { get; }
+public int ILOffset { get; }
```

Removed method:

```csharp
public virtual void MarkSequencePoint (System.Diagnostics.SymbolStore.ISymbolDocumentWriter document, int startLine, int startColumn, int endLine, int endColumn);
```

Added property:

```csharp
public override bool IsConstructedGenericMethod { get; }
```

Removed methods:

```csharp
public void AddDeclarativeSecurity (System.Security.Permissions.SecurityAction action, System.Security.PermissionSet pset);

[Obsolete ("An alternate API is available: Emit the MarshalAs custom attribute instead.")]
public void SetMarshal (UnmanagedMarshal unmanagedMarshal);
public void SetSymCustomAttribute (string name, byte[] data);
```

Removed properties:

```csharp
public override int MetadataToken { get; }
public override System.Guid ModuleVersionId { get; }
public override string ScopeName { get; }
```

Removed methods:

```csharp
public System.Diagnostics.SymbolStore.ISymbolDocumentWriter DefineDocument (string url, System.Guid language, System.Guid languageVendor, System.Guid documentType);
public void DefineManifestResource (string name, System.IO.Stream stream, System.Reflection.ResourceAttributes attribute);
public System.Resources.IResourceWriter DefineResource (string name, string description);
public System.Resources.IResourceWriter DefineResource (string name, string description, System.Reflection.ResourceAttributes attribute);
public void DefineUnmanagedResource (byte[] resource);
public void DefineUnmanagedResource (string resourceFileName);
public override object[] GetCustomAttributes (bool inherit);
public override object[] GetCustomAttributes (System.Type attributeType, bool inherit);
public override System.Reflection.FieldInfo GetField (string name, System.Reflection.BindingFlags bindingAttr);
public override System.Reflection.FieldInfo[] GetFields (System.Reflection.BindingFlags bindingFlags);
protected override System.Reflection.MethodInfo GetMethodImpl (string name, System.Reflection.BindingFlags bindingAttr, System.Reflection.Binder binder, System.Reflection.CallingConventions callConvention, System.Type[] types, System.Reflection.ParameterModifier[] modifiers);
public override System.Reflection.MethodInfo[] GetMethods (System.Reflection.BindingFlags bindingFlags);
public System.Diagnostics.SymbolStore.ISymbolWriter GetSymWriter ();
public override System.Type GetType (string className);
public override System.Type GetType (string className, bool ignoreCase);
public override System.Type GetType (string className, bool throwOnError, bool ignoreCase);
public override System.Type[] GetTypes ();
public override bool IsDefined (System.Type attributeType, bool inherit);
public override bool IsResource ();
public override System.Reflection.FieldInfo ResolveField (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public override System.Reflection.MemberInfo ResolveMember (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public override System.Reflection.MethodBase ResolveMethod (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public override byte[] ResolveSignature (int metadataToken);
public override string ResolveString (int metadataToken);
public override System.Type ResolveType (int metadataToken, System.Type[] genericTypeArguments, System.Type[] genericMethodArguments);
public void SetSymCustomAttribute (string name, byte[] data);
```

Modified properties:

```diff
-public virtual int Attributes { get; }
+public int Attributes { get; }
-public virtual string Name { get; }
+public string Name { get; }
-public virtual int Position { get; }
+public int Position { get; }
```

Removed method:

```csharp
[Obsolete ("An alternate API is available: Emit the MarshalAs custom attribute instead.")]
public virtual void SetMarshal (UnmanagedMarshal unmanagedMarshal);
```

Removed interface:

```csharp
System.Runtime.InteropServices._SignatureHelper
```

Removed methods:

```csharp
public override bool Equals (object obj);
public override int GetHashCode ();
public override string ToString ();
```

Removed property:

```csharp
public override bool ContainsGenericParameters { get; }
```

Added properties:

```csharp
public override bool IsByRefLike { get; }
public override bool IsSZArray { get; }
public override bool IsSecurityCritical { get; }
public override bool IsSecuritySafeCritical { get; }
public override bool IsSecurityTransparent { get; }
public override bool IsVariableBoundArray { get; }
```

Removed methods:

```csharp
public void AddDeclarativeSecurity (System.Security.Permissions.SecurityAction action, System.Security.PermissionSet pset);
public override bool IsAssignableFrom (System.Reflection.TypeInfo typeInfo);
protected override bool IsValueTypeImpl ();
```

Removed methods:

```csharp
public static object GetActiveObject (string progID);
public static IntPtr GetComInterfaceForObjectInContext (object o, System.Type t);
public static int GetComSlotForMethodInfo (System.Reflection.MemberInfo m);
public static int GetEndComSlot (System.Type t);
public static IntPtr GetExceptionPointers ();
public static IntPtr GetIDispatchForObjectInContext (object o);
public static IntPtr GetITypeInfoForType (System.Type t);
public static IntPtr GetIUnknownForObjectInContext (object o);

[Obsolete ("This method has been deprecated")]
public static IntPtr GetManagedThunkForUnmanagedMethodPtr (IntPtr pfnMethodToWrap, IntPtr pbSignature, int cbSignature);
public static System.Reflection.MemberInfo GetMethodInfoForComSlot (System.Type t, int slot, ref ComMemberType memberType);

[Obsolete ("This method has been deprecated")]
public static System.Threading.Thread GetThreadFromFiberCookie (int cookie);
public static System.Type GetTypeForITypeInfo (IntPtr piTypeInfo);

[Obsolete]
public static string GetTypeInfoName (UCOMITypeInfo pTI);
public static System.Guid GetTypeLibGuid (ComTypes.ITypeLib typelib);

[Obsolete]
public static System.Guid GetTypeLibGuid (UCOMITypeLib pTLB);
public static System.Guid GetTypeLibGuidForAssembly (System.Reflection.Assembly asm);
public static int GetTypeLibLcid (ComTypes.ITypeLib typelib);

[Obsolete]
public static int GetTypeLibLcid (UCOMITypeLib pTLB);
public static string GetTypeLibName (ComTypes.ITypeLib typelib);

[Obsolete]
public static string GetTypeLibName (UCOMITypeLib pTLB);
public static void GetTypeLibVersionForAssembly (System.Reflection.Assembly inputAssembly, out int majorVersion, out int minorVersion);

[Obsolete ("This method has been deprecated")]
public static IntPtr GetUnmanagedThunkForManagedMethodPtr (IntPtr pfnMethodToWrap, IntPtr pbSignature, int cbSignature);
public static bool IsTypeVisibleFromCom (System.Type t);
public static int NumParamBytes (System.Reflection.MethodInfo m);

[Obsolete]
public static void ReleaseThreadCache ();
```

* [csproj] Update project files

* Bump API snapshot submodule
2019-05-28 14:48:24 +02:00
Alexander Köplinger af47bd50b2 [sdks] Explicitly set version of the mac/ios/watchos/tvos platform SDKs (#14663)
Otherwise the Xcode linker tries to guess the version from the path,
and since we use Xcode101.app it'd use sdk=101 as the version which is wrong.

By explicitly specifying e.g. `$(XCODE_DIR)/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS12.1.sdk`
as the sysroot it correctly guesses sdk=12.1 instead.

See also https://github.com/xamarin/xamarin-macios/commit/834c0a9fd7062c0c25011721fd7d524b8a60b41e

(cherry picked from commit 7ca8e89ce7)
2019-05-28 01:39:17 +02:00
monojenkins 4766e2227a [2019-04] [System] Fix monotouch_runtime repl assemblies (#14638)
They were missing some exclude files that caused unnecessary p/invokes to be retained.

Fixes https://github.com/mono/mono/issues/13526
2019-05-27 14:01:57 +02:00
monojenkins 02d008c624 [2019-04] [System.Core] Ensure monotouch[_runtime] API are identical (#14617)
* [System.Core] Ensure monotouch[_runtime] API are identical

Ensure the API surface for `System.Core.dll` is identical between the
`monotouch` and `monotouch_runtime` (used for REPL and the interpreter).

This ensure code compiled against one will be fine when building against
the other (e.g. avoiding linker errors).

Removed methods:

```csharp
public void CompileToMethod (System.Reflection.Emit.MethodBuilder method);
public void CompileToMethod (System.Reflection.Emit.MethodBuilder method, System.Runtime.CompilerServices.DebugInfoGenerator debugInfoGenerator);
```

Removed methods:

```csharp
[Obsolete ("do not use this method")]
public static IRuntimeVariables MergeRuntimeVariables (IRuntimeVariables first, IRuntimeVariables second, int[] indexes);

[Obsolete ("do not use this method")]
public static System.Linq.Expressions.Expression Quote (System.Linq.Expressions.Expression expression, object hoistedLocals, object[] locals);
```

* [csproj] Update project files

* Bump API snapshot submodule
2019-05-24 15:39:50 +02:00
monojenkins 0c0df14755 [2019-04] Throw ObjectDisposedException instead of crashing when Cairo.Context handle == IntPtr.Zero (#14626)
* Throw ObjectDisposedException instead of crashing when Cairo.Context.handle == IntPtr.Zero

We are seeing instances where VS for Mac is crashing with a SIGSEGV when
calling into certain Cairo.Context functions.  Looking at the code, it's clear
that it's possible to have Context.handle == IntPtr.Zero after disposing the
object.

From research, it looks like passing a nullptr to raw cairo functions can
result in a SIGSEGV:
    https://bugs.launchpad.net/ubuntu/+source/compiz/+bug/93807

This change adds check to see if Conext.handle == IntPtr.Zero in Context
painting, font, and path methods.  This will turn uncatchable SIGSEGVs
into ObjectDisposedException.

* Update Context.cs

* Ensure SetTarget results in a valid handle
2019-05-24 15:20:08 +02:00
Alexander Köplinger 9a3a2665f0 [sdks] Fix min OSX version of runtime files in Mac SDK (#14615)
It was using an unescaped makefile variable in the template, i.e. ended up empty which meant the build just took the host version as the min version.

Fixed the variable and also moved it to CFLAGS/CXXFLAGS instead of CPPFLAGS to be consistent with ios.mk

(cherry picked from commit 82a9931248)
2019-05-24 14:11:21 +02:00
Alexander Köplinger c01bc7bca9 [tests] Add xunit.execution.dotnet.dll to tests directory (#14595)
So it gets included in the sdks archive

(cherry picked from commit f5f3c6aabe)
2019-05-23 20:18:42 +02:00
Bernhard Urban 9d909ca613 [arm] one more attempt to fix slotsize issue on llvmonly (#14444) (#14534)
[2019-04] [arm] one more attempt to fix slotsize issue on llvmonly (#14444)

Backport of https://github.com/mono/mono/pull/14444
2019-05-23 10:00:37 -04:00
Marek Habersack 26b9087b44 [Android] Fix runtime loading of DSOs for 64-bit processes
Context: https://github.com/xamarin/xamarin-android/issues/2780

On Android the executable for the application is going to be
`/system/bin/app_process{32,64}` depending on the application's architecture.
However, libraries for the different architectures live in different
subdirectories of `/system`: `lib` for 32-bit apps and `lib64` for 64-bit ones.
Thus appending `/lib` below will fail to load the DSO for a 64-bit app, even if
it exists there, because it will have a different architecture. The quickest fix
is to use `lib64` explicitly for 64-bit Android apps.
2019-05-23 10:46:30 +02:00
Alexander Köplinger a3d0f993c2 [tests] Add Xunit.NetCore.Extensions.dll to tests directory (#14571)
So it gets included in the sdks archive

(cherry picked from commit 2c76de1ee1)
2019-05-22 19:48:58 +02:00
Alexander Köplinger 92e73f22ea [2019-04] Bump gtk-sharp in bockbuild
Brings in mono/gtk-sharp#273.

Cherry-pick of https://github.com/mono/mono/pull/14537
2019-05-21 11:39:07 +02:00
monojenkins 4caae35744 [interp] disable inlining for built-in types (#14530)
[2019-04] [interp] disable inlining for built-in types

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

Backport of #14501.

/cc @lewurm
2019-05-20 16:16:11 -04:00
Alexander Köplinger d4e20f02e8 [sdks] Lipo arm64_32 binaries for watchOS
(cherry picked from commit ca5e8f207b)
2019-05-12 17:48:09 -07:00
monojenkins f506b6556b [2019-04] [WinForms] fix EditingCellFormattedValue getter and setter for bool value (#14436)
* [WinForms] If DataGridViewCheckBoxCell not in threeState mode EditingCellFormattedValue must return true or false, instead of value of CheckState type

* [WinForms] DataGrid: fix type check in EditingCellFormattedValue setter. When set bool value to EditingCellFormattedValue there will be exception. Type equality must be done through IsAssignableFrom not direct

* [WinForms] DataGrid: Add test for EditingCellFormattedValue getter and setter.
2019-05-12 05:39:39 -07:00
monojenkins cfd117ef41 [2019-04] Revert "[System] Add FSEvent FileSystemWatcher to monotouch BCL profile" (#14447)
* Revert "[System] Add FSEvent FileSystemWatcher to 'monotouch' BCL profile"

This reverts commit 46fc5352f3dfe0027e684a0f61e71130fccd559f.

While iOS FileSystemWatcher works, we now find that it is used unofficially-available  symbols and cannot publish apps using those.

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

* [csproj] Update project files
2019-05-12 05:21:40 -07:00
monojenkins 719fd63c43 [2019-04] [runtime] Use MAP_JIT automatically when running under a hardened runtime on osx. (#14414)
* [runtime] Use MAP_JIT automatically when running under a hardened runtime on osx.

* Fix memory ordering.
2019-05-12 05:19:22 -07:00
monojenkins 7bcbc7c2bf [2019-04] [corlib] Implement AssemblyBuilder.get_ReflectionOnly() (#14457)
* [corlib] Implement AssemblyBuilder.get_ReflectionOnly()

Fixes #13028

* Bump API snapshot submodule
2019-05-12 05:11:27 -07:00
monojenkins 3ac7efc336 [arm64] set MONO_ARCH_HAVE_UNWIND_BACKTRACE for watch4 (#14453)
[2019-04] [arm64] set MONO_ARCH_HAVE_UNWIND_BACKTRACE for watch4

Fixes a couple of mscorlib test failures, failing with
> Stack walks are not supported on this platform


Backport of #14440.

/cc @lewurm
2019-05-11 09:15:44 -04:00
monojenkins 482111976a [metadata] use handle stack in mono_runtime_object_init_handle (#14446)
[2019-04] [metadata] use handle stack in mono_runtime_object_init_handle

Fixes this crash on watchOS with llvmonly:
https://gist.github.com/lewurm/921b77a238c6fd60757a5ee9f54279d1

The hint here was that the crash happened in `mono_handle_stack_scan ()` and inspecting the handle stack there. After enabling `MONO_HANDLE_TRACK_OWNER` and `MONO_HANDLE_TRACK_SP` in `handle.h`, I got this:
https://gist.github.com/lewurm/71f936a126879ef2b96d00399e6b2bd9


@lambdageek suggested this fix after showing this trace to him. As far as I understand we do _not_ know the root cause yet. The handle leak happens in this trace:
https://gist.github.com/lewurm/b76fbc391f22d897bfd532ac1b67e2aa
`mono_runtime_object_init_checked ()` already should take care of the handle stack 😕


Contributes to #13006

Backport of #14399.

/cc @akoeplinger @lewurm
2019-05-10 18:06:04 -04:00
Egor Bogatov 7a8db67341 Update CultureInfoTest.cs 2019-05-10 13:54:54 +02:00
Egor Bogatov dce3386dbb Fix TextView 2019-05-10 13:54:54 +02:00
lateralusX ad01218417 Mutex memory leak on sgen GC (nursery, major).
During GC we allocate a gray queue protected by a mutex, sgen_gray_object_queue_init.
This mutex is never destroyed when clearing up the object containing it,
sgen_gray_object_queue_dispose, so it will leak. Overtime this could cause
OOM on some systems depending on how memory related to system primitives are
handled and partitioned.
2019-05-10 11:08:31 +02:00
Bernhard Urban b8a6096bb1 [2019-04] Do not allocate handles in ReleaseMutex. (#14429)
[2019-04] Do not allocate handles in ReleaseMutex.

Backport of https://github.com/mono/mono/pull/14403
2019-05-10 04:32:27 -04:00
monojenkins c35f4c3e5f Usually do not create a handle in mono_runtime_invoke_handle. Use mono_runtime_invoke_handle_void instead. (#14422)
[2019-04] Usually do not create a handle in mono_runtime_invoke_handle.

Use mono_runtime_invoke_handle_void instead.


Backport of #14404.

/cc @lewurm @jaykrell
2019-05-09 20:15:36 -04:00
Ankit Jain 08d062aca7 Bump msbuild to track mono-2019-04 (#14287) 2019-05-09 12:38:50 -04:00
monojenkins 82601ba547 [llvmonly] make local copy of trace_ips pointer from exception object (#14410)
[2019-04] [llvmonly] make local copy of trace_ips pointer from exception object

Fixes a race in llvmonly (watchOS):
```
Process 397 stopped
* thread %10, name = 'tid_8e2f', stop reason = EXC_BAD_ACCESS (code=1, address=0x28)
    frame %0: 0x0177f690 mscorlibtests`mono_llvm_load_exception at mini-exceptions.c:3886:23
   3883                 size_t upper = mono_array_length_internal (mono_ex->trace_ips);
   3884
   3885                 for (int i = 0; i < upper; i += TRACE_IP_ENTRY_SIZE) {
-> 3886                         gpointer curr_ip = mono_array_get_internal (mono_ex->trace_ips, gpointer, i);
   3887                         for (int j = 0; j < TRACE_IP_ENTRY_SIZE; ++j) {
   3888                                 gpointer p = mono_array_get_internal (mono_ex->trace_ips, gpointer, i + j);
   3889                                 trace_ips = g_list_append (trace_ips, p);
Target 0: (mscorlibtests) stopped.

(lldb) mbt
* thread %10
  * frame %0: 0x0177f690 mscorlibtests`mono_llvm_load_exception at mini-exceptions.c:3886:23
    frame %1: 0x00e23b7a mscorlibtests`mscorlibtests1_MonoTests_System_LazyTest__c__DisplayClass16_0__ConcurrentInitializationb__1 + 254
    frame %2: 0x0087af98 mscorlibtests`mscorlib_wrapper_delegate_invoke__Module_invoke_void + 610
    frame %3: 0x00368856 mscorlibtests`mscorlib_System_Threading_ThreadHelper_ThreadStart_Context_object + 448
  [...]
(lldb) p/x mono_ex
(MonoException *) $2 = 0x01d9e968
(lldb) p/x mono_ex->trace_ips
(MonoArray *) $3 = 0x00000000
(lldb) thread list
Process 397 stopped
  thread %1: tid = 0x38772, 0x018156aa mscorlibtests`jit_info_table_copy_and_split_chunk(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:483:28, name = 'tid_303', queue = 'com.apple.main-thread'
  thread %3: tid = 0x387ad, 0x1c4f9764 libsystem_kernel.dylib`__psynch_cvwait + 24, name = 'SGen worker'
  thread %4: tid = 0x387b0, 0x1c4f1224 libsystem_kernel.dylib`semaphore_wait_trap + 8, name = 'Finalizer'
  thread %5: tid = 0x387b5, 0x1c4fa6cc libsystem_kernel.dylib`__workq_kernreturn + 8
  thread %6: tid = 0x387b6, 0x1c4f11d4 libsystem_kernel.dylib`mach_msg_trap + 20, name = 'com.apple.uikit.eventfetch-thread'
* thread %10: tid = 0x389a6, 0x0177f690 mscorlibtests`mono_llvm_load_exception at mini-exceptions.c:3886:23, name = 'tid_8e2f', stop reason = EXC_BAD_ACCESS (code=1, address=0x28)
  thread %11: tid = 0x38985, 0x1c4f9764 libsystem_kernel.dylib`__psynch_cvwait + 24, name = 'tid_8113'
  thread %12: tid = 0x38986, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %13: tid = 0x38987, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %14: tid = 0x389a3, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %15: tid = 0x389a4, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
  thread %16: tid = 0x389a5, 0x1c4f123c libsystem_kernel.dylib`semaphore_timedwait_trap + 8, name = 'Thread Pool Worker'
(lldb) thread select 1
* thread %1, name = 'tid_303', queue = 'com.apple.main-thread'
    frame %0: 0x018156aa mscorlibtests`jit_info_table_copy_and_split_chunk(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:483:28
   480                          jit_info_table_split_chunk (chunk, &new_table->chunks [j], &new_table->chunks [j + 1]);
   481                          j += 2;
   482                  } else {
-> 483                          new_table->chunks [j] = table->chunks [i];
   484                          ++new_table->chunks [j]->refcount;
   485                          ++j;
   486                  }
(lldb) mbt
* thread %1
  * frame %0: 0x018156aa mscorlibtests`jit_info_table_copy_and_split_chunk(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:483:28
    frame %1: 0x01815304 mscorlibtests`jit_info_table_chunk_overflow(table=0x17635a00, chunk=0x17b767f0) at jit-info.c:579:10
    frame %2: 0x018146ee mscorlibtests`jit_info_table_add(domain=0x16624cc0, table_ptr=0x16624d9c, ji=0x176f4428) at jit-info.c:614:33
    frame %3: 0x01814662 mscorlibtests`mono_jit_info_table_add(domain=0x16624cc0, ji=0x176f4428) at jit-info.c:674:2
    frame %4: 0x0175f5da mscorlibtests`mono_aot_find_jit_info(domain=0x16624cc0, image=0x16c07200, addr=0x00271ff1) at aot-runtime.c:3710:3
    frame %5: 0x0181443e mscorlibtests`mono_jit_info_table_find_internal(domain=0x16624cc0, addr=0x00271ff1, try_aot=1, allow_trampolines=0) at jit-info.c:306:9
    frame %6: 0x018145e0 mscorlibtests`mono_jit_info_table_find(domain=0x16624cc0, addr=0x00271ff1) at jit-info.c:335:9
    frame %7: 0x01780212 mscorlibtests`build_stack_trace(frame_ctx=0x01c2fb18, state=0x01c2ffb8) at mini-exceptions.c:392:31
    frame %8: 0x1c598aa2 libunwind.dylib`_Unwind_Backtrace + 232
    frame %9: 0x0177f4fc mscorlibtests`throw_exception(ex=0x01d9e968, rethrow=0) at mini-exceptions.c:3800:3
    frame %10: 0x0177f3c8 mscorlibtests`mono_llvm_throw_exception(ex=0x01d9e968) at mini-exceptions.c:3823:2
    frame %11: 0x00439ed0 mscorlibtests`mscorlib_System_Runtime_ExceptionServices_ExceptionDispatchInfo_Throw + 116
    frame %12: 0x00271ff0 mscorlibtests`mscorlib_System_LazyHelper_ThrowException + 98
    frame %13: 0x002730c2 mscorlibtests`mscorlib_System_Lazy_1_T_REF_CreateValue + 194
    frame %14: 0x00273390 mscorlibtests`mscorlib_System_Lazy_1_T_REF_get_Value + 128
    frame %15: 0x0027307a mscorlibtests`mscorlib_System_Lazy_1_T_REF_CreateValue + 122
    frame %16: 0x00273390 mscorlibtests`mscorlib_System_Lazy_1_T_REF_get_Value + 128
    frame %17: 0x00e22eb0 mscorlibtests`mscorlibtests1_MonoTests_System_LazyTest_ConcurrentInitialization + 1422
    frame %18: 0x008948e2 mscorlibtests`aot_wrapper_gsharedvt_out_sig_pinvoke_void_this_ + 28
    frame %19: 0x008664a2 mscorlibtests`mscorlib_wrapper_runtime_invoke_object_runtime_invoke_sig_void_intptr_intptr_object_intptr_intptr_intptr + 312
```


Contributes to #13006

Backport of #14400.

/cc @lewurm
2019-05-09 12:06:28 -04:00
Alexander Köplinger 7d5deb616d [sdks] Add .cs source files to ios archive
XI/XM install the Mono sources as part of their package.

(cherry picked from commit a597cee5b0)
2019-05-09 17:25:43 +02:00
monojenkins a0ae702117 A deadlock happens when during a process_suspend there is a pending invoke and then when it's calling the invoke there is another call to process_suspend in the same thread. (#14388) 2019-05-09 10:24:45 -03:00
Alexander Köplinger aee4ff6671 [sdks] Make sure the mono-version.txt directory exists
(cherry picked from commit 8370fe318b)
2019-05-09 11:49:24 +02:00
Alexander Köplinger 30e8a2329b Bump helix-binaries
Helix recently started using Python 3 so we need to have a compatible xunit-reporter.py script.

(cherry picked from commit be571243e4)
2019-05-09 10:40:02 +02:00
Alexander Köplinger 1e96a5cfe6 [sdks] Add Mono version to ios/mac archive 2019-05-08 17:09:10 +02:00
Alexander Köplinger a98c697a6d [sdks] Add Mono binaries to mac archive 2019-05-08 12:45:07 +02:00
monojenkins a5c39e9ac4 [2019-04] [loader] Don't store through a null ptr (#14112)
* [loader] Dont't store through a null ptr

If 'status' is null, don't try to write to it.

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

* [metadata] Protect writes to MonoImageOpenStatus* in a few places.

When possible assert that `MonoImageOpenStatus *status` arguments to various
functions in the runtime aren't null.  There are a few places (MONO_API) where
it's possible that callers are passing null.  In that case, use a local
MonoImageOpenStatus, or check for null before doing assignments.
2019-05-07 20:41:23 +02:00
Alexis Christoforides 11e10a07ad [corlib] Fix exception 'replacement' in IsolatedStorageFile.MoveFile()
This was caused by changes in File.Move coming from https://github.com/mono/mono/pull/12000
2019-05-07 14:34:03 -04:00
monojenkins 10db3b9dd0 [debugger-agent] Ignore thread_end event if thread is detached (#14003)
The thread_stopped profiler event can be raised by the thread_info_key_dtor tls
key destructor when the thread is already doesn't have a domain set.  In that
case, don't call process_profiler_event since it cannot handle a thread with
null TLS values.

Addresses https://github.com/xamarin/xamarin-android/issues/2920
with the following stack trace

```
* thread #20, name = 'Filter', stop reason = signal SIGSEGV: invalid address (fault address: 0xbc)
  * frame #0: libmonosgen-2.0.so`mono_class_vtable_checked(domain=0x0000000000000000, klass=0x0000007200230648, error=0x00000071e92f9178) at object.c:1890
    frame #1: libmonosgen-2.0.so`get_current_thread_ptr_for_domain(domain=0x0000000000000000, thread=0x00000071ebfec508) at threads.c:595
    frame #2: libmonosgen-2.0.so`mono_thread_current at threads.c:1939
    frame #3: libmonosgen-2.0.so`process_event(event=<unavailable>, arg=<unavailable>, il_offset=<unavailable>, ctx=<unavailable>, events=<unavailable>, suspend_policy=<unavailable>) at debugger-agent.c:3715
    frame #4: libmonosgen-2.0.so`thread_end [inlined] process_profiler_event(event=EVENT_KIND_THREAD_DEATH, arg=0x00000071ebfec508) at debugger-agent.c:3875
    frame #5: libmonosgen-2.0.so`thread_end(prof=<unavailable>, tid=<unavailable>) at debugger-agent.c:3991
    frame #6: libmonosgen-2.0.so`mono_profiler_raise_thread_stopped(tid=<unavailable>) at profiler-events.h:105
    frame #7: libmonosgen-2.0.so`mono_thread_detach_internal(thread=<unavailable>) at threads.c:979
    frame #8: libmonosgen-2.0.so`thread_detach(info=0x00000071e949a000) at threads.c:3215
    frame #9: libmonosgen-2.0.so`unregister_thread(arg=<unavailable>) at mono-threads.c:544
    frame #10: libmonosgen-2.0.so`thread_info_key_dtor(arg=0x00000071e949a000) at mono-threads.c:774
    frame #11: 0x00000072899c58e8 libc.so`pthread_key_clean_all() + 124
    frame #12: 0x00000072899c5374 libc.so`pthread_exit + 76
    frame #13: 0x00000072899c5264 libc.so`__pthread_start(void*) + 44
    frame #14: 0x000000728996617c libc.so`__start_thread + 72
```
2019-05-07 20:22:46 +02:00
monojenkins 186a3b768e [2019-04] [corlib] Fix a few NSLogWriter issues. (#13952)
* [corlib] Make NSLogWriter thread-safe.

* [corlib] Simplify newline checking in NSLogWriter.

Checking the StringBuilder buffer after writing to it instead of the input
string/char[] makes the code somewhat simpler.

* [corlib] Fix NSLogWriter.Write to take into account the index and count parameters.
2019-05-07 20:21:33 +02:00
monojenkins cd42fa383f [arm] fix armv7k regression on struct passing (#14380)
[2019-04] [arm] fix armv7k regression on struct passing

We can't use `slotsize=8` on `armv7k` as it leads to stack corruption.

Note that `mtouch` already calls the AOT compiler with `--aot=mtriple=arm64_32-ios`, so no changes are required there.

Regression introduced by https://github.com/mono/mono/pull/12992

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


Backport of #14362.

/cc @lewurm
2019-05-07 11:37:30 -04:00
Alexander Köplinger 3134b554ed [sdks] Add Mono libraries to mac archive 2019-05-07 17:19:43 +02:00
Alexander Köplinger c716c2200b [sdks] Add mono-2.pc to mac archive
Xamarin.Mac needs it.
2019-05-07 15:59:38 +02:00
Alexander Köplinger 4616c1c2d6 [sdks] Add Mono libraries and frameworks to iOS archive 2019-05-07 15:59:38 +02:00
Alexander Köplinger 6f7e90d908 [sdks] Remove --with-monotouch from configure arguments
They are only needed for BCL builds and those are disabled by --disable-mcs-build
2019-05-07 15:59:38 +02:00
Alexander Köplinger bec31562b2 [sdks] Fix README.md 2019-05-07 15:59:38 +02:00
monojenkins 18b454c267 Bump API snapshot submodule 2019-05-06 15:02:14 +02:00
Marek Safar 5ce3f8f62b [Facades] Include missing enums in System.Memory 2019-05-06 15:02:14 +02:00
Alexander Köplinger 6c135b00e3 [tests] Write nunit/xunit exclude categories to a file (#14281)
So we can include it in the SDKs archive.

(cherry picked from commit 4eea0870e1)
2019-05-06 14:01:19 +02:00
monojenkins 1a105af0bc [arm] amend stack pointer properly in exception trampoline (#14314)
[2019-04] [arm] amend stack pointer properly in exception trampoline

The previous attempt ( https://github.com/mono/mono/pull/14078 ) only fixed it for ABIs where the stack pointer alignment is 8 bytes. ABIs, such as watchOS, require 16 byte alignment.

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

Backport of #14310.

/cc @lewurm
2019-05-03 13:56:18 -04:00
Zoltan Varga fd4b429551 [aot] Avoid passing -march=arm to llc when using thumb, it forces arm32 code generation.
Fixes https://github.com/mono/mono/issues/14247.
2019-05-02 15:46:37 +02:00
monojenkins 705aa0209b [2019-04] [corlib] Add API that was dropped during the coreFX System.IO integra… (#14275)
* [corlib] Add API that was dropped during the coreFX System.IO integration

* Bump API snapshot submodule
2019-05-01 14:23:21 -04:00
Jay Krell 9091e89cbf Remove libgcc_s_seh-1.dll dependency when targeting Win32 with gcc. (#14251)
Don't use popcount intrinsic.
Alternative but not exactly contradictory to https://github.com/mono/mono/pull/14248.

Note that this is a single inlinable instruction on x86,
if you assume at least SSE4 from circa 2007, which I am avoiding here.

(cherry picked from commit 90a91429ae)
2019-04-29 16:14:35 +02:00
Alexander Köplinger 64630570f7 [nunit-lite] Use .NOTPARALLEL to possibly fix some races
We're seeing occasional build errors on CI that seem to be some kind
of race when compiling nunit-lite and nunit-lite-console.

(cherry picked from commit c3541fc543)
2019-04-29 14:12:29 +02:00
Vlad Brezae dd06ea25fa [interp] Fix GetFunctionPointer (#14176)
This method returns a function pointer that can be called with a calli instruction. On interpreter we use a pointer to InterpMethod while on jit we use the native code address. Normally, GetFunctionPointer should return the InterpMethod pointer if called from interp or the native code address if called from jit. Since we don't have any information about the execution engine of the caller, we solve this by intrinsifying all these calls, that happen in the interpreter.

Passing such function pointers between jitted and interp code is probably still unreliable.

Fixes https://github.com/mono/mono/issues/13654
2019-04-26 21:10:08 +02:00
monojenkins c1b2d24d3b [2019-04] Fix arm32 tailcall_reg/tailcall_membase. (#14236)
* When moving parameters for tailcall, and having pushed ip, and adjusting the offset to account for that, split the adjustment between sp and frame pointer, as frame pointer may or may not be sp. This fixes https://github.com/mono/mono/issues/11489.

* Revert "[Tailcall] [arm] [jit] Fix moving tailcall parameters. (#12701)"

This reverts commit 257efc6374.
2019-04-26 10:53:21 -04:00
monojenkins b7cc391243 [interp] fix op_explicit for cast from nfloat to nint and vice versa (#14222)
[2019-04] [interp] fix op_explicit for cast from nfloat to nint and vice versa

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

/cc @spouliot 

Backport of #14201.

/cc @lewurm
2019-04-25 05:36:18 -04:00
monojenkins 28a266a434 [2019-04] [interp] Fix interp strmfld vt (#14212)
* [interp] Fix store remote value type field

Looks like the culprit for some random mcs tests failures

* [interp] Delete dummy code
2019-04-25 12:07:08 +03:00
monojenkins f103f5ce57 [2019-04] [acceptance-tests] Run roslyn tests using in-tree mono instead of system mono (#14198)
We were inadvertently running the roslyn tests against the system mono in CI.
Instead we now install mono to a custom prefix, prepend that to PATH and run
the roslyn tests against the correct mono we just built.
2019-04-24 11:30:46 +02:00
monojenkins 525877cfe1 [aot] partial revert of #14043 (#14138)
[2019-04] [aot] partial revert of #14043

We need to emit a real call here. On arm/android we would emit this now:
```asm
ldr pc, =label
.ltorg         # place address of `label` here.
```
which is a jump to `label`, not a call.

We need a different solution to make larger assemblies work, but for now
I revert it so the `2019-02` intergration is unblocked.

Partial revert of #14043


Backport of #14135.

/cc @lewurm
2019-04-23 11:46:27 -04:00
monojenkins 3d2df4c76e [interp] Fix buffer overflow when incrementing sp (#14148)
Fixes https://github.com/mono/mono/issues/14079
2019-04-23 16:46:03 +03:00
monojenkins fc25025f64 [2019-04] Protecting boxing a null value (#14115)
When a static method is called the obj is not used, so it can be null and it doesn't need to be boxed. Adding an assert in the method to prevent other crash in this method if a NULL is received.
2019-04-18 11:39:40 -03:00
Jay Krell 1c08f4db80 Increase gsharedvt trampolines by 10% from 4000 to 4400.
There are many minor arguments here.

Where this matters most -- iOS -- the pool is already dynamic.

Other platforms could use a dynamic pool or JIT (despite FullAOT).
Using JIT would defeat the test coverage.

Mitigates https://github.com/mono/mono/issues/13888.
If this feels too tenative, go bigger.
2019-04-18 14:02:32 +02:00
monojenkins 030986fed7 [2019-04] [aot] change method table generation so that it works for larger assemblies on ARM (#14053)
[2019-04] [aot] change method table generation so that it works for larger assemblies on ARM

At the end of the AOT compilation, we dump a table containing all method
entrypoints using the toolchain linker to resolve the addresses. Previously
we used `bl` for that, however on larger assemblies the offset might
overflow the 24bit immediate (thus, the linker bailing out with
"Error: branch out of range"). Instead, using `ldr pc,=<label>` followed
by `.ltorg` emits the full 32bit address to a method. That takes 8 bytes
for each method instead of 4 bytes.


( I couldn't reopen https://github.com/mono/mono/pull/3486 anymore)

Backport of #14043.

/cc @marek-safar @lewurm
2019-04-16 17:55:54 -04:00
monojenkins 0f956be2e8 [arm] align stack pointer in throw trampoline (#14085)
[2019-04] [arm] align stack pointer in throw trampoline

This is a regression introduced by e46fa20466

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

Backport of #14078.

/cc @akoeplinger @lewurm
2019-04-16 16:16:20 -04:00
Alexis Christoforides 68eea797de [MacSDK] Bump F# to 4.5 (#10919) (#14058)
* Use a custom prefix instead of trying to infer it, which doesn't work under bockbuild.

The following line is problematic in the scope of building the Mac SDK package (using bockbuild):

https://github.com/fsharp/fsharp/blob/ccfccbacfdb16b2ab143cf83f5ece20f738fd864/mono/config.make#L5

It's problematic because where `mono` lives in this case would be something like `/macsdk-staging-dir/bin/mono` which is not the actual prefix (prefix here being the final destination, `/Library/Frameworks/Mono.framework/...`) but a staging area that bockbuild uses (this is how we build on system prefixes without installing on CI)

For the F# build, bockbuild expects things to end up  in `/fsharp-staging-dir/$(prefix)` (because that's what most `make install`s do when given `DESTDIR=/fsharp-staging-dir/`). If things end up in _any other_ directory in `/fsharp-staging-dir/`  (like `/fsharp-staging-dir/macsdk-staging-dir` in our case) that would cause us to miss packaging those files (this has happened before, with packages that have broken or different use of `DESTDIR`). So there is an added write-protection for anywhere in `/fsharp-staging-dir` that *isn't*  `/fsharp-staging-dir/$(prefix)` , because a write-protection error, while obtuse, is much preferable to missing the fact that some files are not packaged (as would have happened here)

So the fix is to stop trying to infer the prefix, and return to providing it explicitly to the build system (this used to be the case via the `configure` step)

* Also, if we are doing an override of the 'make' command, we need to take care of passing DESTDIR ourselves too

* Since now we perform 'make install' on the make step, make the 'install' step into a no-operation.

* Look for sn where mono is, not in the final destination (which again, may not be the same)
2019-04-16 09:43:19 -04:00
sancheolz 73430f2f78 [WinForms] Fix displayed image in TreeNode when ImageIndex set to -2 When ImageIndex in TreeNode set to -2 must not displayed any image 2019-04-15 14:26:45 +02:00
Alexander Köplinger c3c1df05ba [corlib] Disable FileTest.SymLinkStats() on TVOS
Symlinks on TVOS run into sandboxing restrictions. We've already disabled a similar test.

This test was added recently as part of 26e0b1deec.

(cherry picked from commit b85fdbdb10)
2019-04-12 14:27:32 +02:00
Maxim Lipnin a184b94276 Remove #if-def for TypedReference.MakeTypedReference readonly restriction 2019-04-12 10:54:24 +02:00
Maxim Lipnin a5c373ff40 [w32error] Add ENONET error case 2019-04-12 08:29:15 +02:00
Zoltan Varga 453c277692 [jit] Make dlmalloc use mono_valloc so it picks up the MAP_JIT flag on osx.
Fixes https://github.com/mono/mono/issues/13878.
2019-04-12 08:28:18 +02:00
Aleksey Kliger 432e2032c9 [utils] stub mono_setmmapjit on Win32 and Wasm 2019-04-12 08:27:34 +02:00
Miguel de Icaza 31efbed2fe Do not use MAP_JIT by default, instead make this something that is toggled by Xamarin.Mac which needs it 2019-04-12 08:27:34 +02:00
Ankit Jain a0d6820d94 [nuget] Bump to nuget 5.0.0 2019-04-11 13:39:15 +02:00
Alexander Köplinger d7431c205e [cil-strip] Fix reading of undefined NativeType values in old Cecil
cil-strip crashed when processing this method: https://github.com/mono/corefx/blob/f54e64b341a7b114c3502e197b46670cacb28639/src/Microsoft.CSharp/tests/DefaultParameterTests.cs#L88

It uses `MarshalAs((UnmanagedType)2000)`, i.e. an undefined value for the
native type. The old Cecil embedded in cil-strip tried to read more than one
byte which blows up in this case. Upstream Cecil just reads a single byte:
https://github.com/jbevain/cecil/blob/1b79b96d29f1e8e9ba832191b1b42ea9cb750d20/Mono.Cecil/AssemblyReader.cs#L3700-L3703

Fixes https://github.com/mono/mono/issues/13639
2019-04-11 13:38:06 +02:00
Alexander Köplinger 342edb8e52 [corlib] Disable a ParameterInfoTest test on MONOTOUCH
It needs SRE and even with interpreter config this doesn't work yet.

(cherry picked from commit 766b3204c3)
2019-04-10 21:00:11 +02:00
Alexander Köplinger aecfd90d2a [configure] Add failsafe for missing submodules (#13957)
GitHub provides a way to download a .zip/.tar.gz of the repository content in their UI, however the archive doesn't contain git submodules.

The mono build then fails with confusing "missing file" errors.

Since GitHub doesn't let us disable the archive download we should at least add some logic to detect this broken case and bail out.

(cherry picked from commit e8caaa1dbd)
2019-04-10 15:26:48 +02:00
Alexander Köplinger 1e53aaa2b3 [System.Net.Http] Make some tests specific to HttpClientHandler
Otherwise they throw PNSE on e.g. WatchOS.

(cherry picked from commit 0b6dbfa349)
2019-04-10 15:03:59 +02:00
monojenkins d9d7943901 [metadata] Don't free_aggregate_modifiers in mono_metadata_free_type (#13796)
The aggregate modifiers container is owned by a MonoImageSet.  The aggregate
modifiers may be shared by more than one MonoType that happen to need the same
modifiers. (Similar to how generic instantiations are shared)

When the image set is cleaned up the aggregate modifier cleanup will free the
types in the aggregate modifiers container (the call to
free_aggregate_modifiers in mono_metadata_clean_for_image).

With this extra call to free_aggregate_modifiers in mono_metadata_free_type may
cause the same memory to be freed twice.

Fixes https://github.com/mono/mono/issues/13775
2019-04-09 18:51:21 -04:00
Bernhard Urban 5fd5f4ab42 [AOT] fix winaot LLVM profile (#13909) (#13944)
[2019-04] [AOT] fix winaot LLVM profile

Regression due to https://github.com/mono/mono/pull/13877

Backport of #13909
2019-04-09 15:05:52 -04:00
monojenkins 5ab8c20e76 [2019-04] [merp] Restore non-assertion behavior in debugger-engine.c (#13932)
In my batch of changes here: https://github.com/mono/mono/commit/c3fe80a0c43be780e35f3a4091d3dc1023b35a00#diff-dca5f20c7ac28a5a4487805c49836fdbL340

I changed

```
			if (!seq_points)
				/* Could be AOT code */
				continue;
```

into

```
			seq_points = (MonoSeqPointInfo *) ji->seq_points;

			if (!seq_points) {
				MonoMethod *jmethod = jinfo_get_method (ji);
				if (jmethod->is_inflated) {
					MonoJitInfo *seq_ji;
					MonoMethod *declaring = mono_method_get_declaring_generic_method (jmethod);
					mono_jit_search_all_backends_for_jit_info (domain, declaring, &seq_ji);
					seq_points = (MonoSeqPointInfo *) seq_ji->seq_points;
				}
			}
```

which doesn't account for the case when it can't find the seq_points. When seq_points is NULL at the end of that block, we don't `continue;` as we did before. Instead we assert, and crash the runtime.

This PR undoes this change, making us continue if `!seq_points`.

Backport of #13865.
2019-04-09 11:29:06 +02:00
Alexander Köplinger 56ce963113 [System.Data] Remove unnecessary file from xunit tests (#13935)
It contained DllImports to some Windows APIs which causes issues on xamarin-macios which expects all pinvokes to exist.

Turns out we don't even need that file.

(cherry picked from commit 3903a50e43)
2019-04-08 23:52:00 +02:00
monojenkins 8d6a92f914 [AOT] remove confusing llcopts flag (#13911)
[2019-04] [AOT] remove confusing llcopts flag

Introduced by
https://github.com/mono/mono/commit/2eeaf888c1d0a681c8705bd609f76196d8fb82ed



Backport of #13877.

/cc @lewurm
2019-04-08 13:56:05 -04:00
Alexander Köplinger b3ff0883cc Bump bockbuild to get GTK fix (#13912)
https://github.com/mono/bockbuild/pull/93
2019-04-08 15:49:13 +02:00
Aleksey Kliger 982adf1ac4 [mono-dl] Don't do thread state transitions in mono_dl_fallback_register
1. it doesn't touch the managed runtime

2. it may be called (arguably it ought to be called only) before the runtime is
initialized (and in particular before the current thread is attached).
2019-04-05 16:04:41 -04:00
monojenkins daf75c61ca [gsharedvt] Fix sizeof opcode (#13832)
[2019-04] [gsharedvt] Fix sizeof opcode

We were setting the stack type by using another global local named ins.

This lead to missing methods in the aot image due to invalid IL. Fixes https://github.com/mono/mono/issues/13479.

Backport of #13817.

/cc @lewurm @BrzVlad
2019-04-04 09:55:23 -04:00
Alexander Köplinger ba238de63b Update csproj file
(cherry picked from commit e75ba60277)
2019-04-04 11:10:15 +02:00
Alexander Köplinger 21e76d610e [corlib] Disable EncodingTest.AllEncodingsAreSerializable() on XM4.5 too
(cherry picked from commit 9eb2dbf4cc)
2019-04-04 01:57:10 +02:00
Alexander Köplinger 84aa2ebf15 [MacSDK] Bump bockbuild for fix to #13804 2019-04-04 00:14:25 +02:00
Alexander Köplinger 4d67a0f9f2 [2019-04] Bump linker to latest master (#13818)
(cherry picked from commit 6717c3422a)
2019-04-03 23:40:32 +02:00
Alexander Köplinger 0796cd6829 [System] Clear MONO_CFG_DIR before starting mcs in CodeDOM CSharpCodeGenerator for XM4.5 (#13742)
* [System] Clear MONO_CFG_DIR before starting mcs in CodeDOM CSharpCodeGenerator

This showed up in the xamarin-macios 2019-02 integration.
When you used Xslt with a custom C# script in a Xamarin.Mac Full application
we'd try to launch mcs via CodeDOM to compile the script.

This started failing in 2019-02 because System.Native (mono-native) wasn't found,
the reason is that XM sets MONO_CFG_DIR to point to the Contents/MonoBundle
in the app bundle where it packages the global config file with dllmaps.

However the started Mono wasn't able to find mono-native since the config
there uses a different name for the file.

To prevent that we now clear MONO_CFG_DIR so it uses the default value for the
mono process we're starting (note that setting it to String.Empty doesn't work)

* Make it specific to XM 4.5

(cherry picked from commit 448cf31a8d)
2019-04-02 10:46:33 +02:00
Jo Shields 2046cf5d26 Fix tarball builds
(cherry picked from commit 262a543a17)
2019-04-01 15:52:05 -04:00
Alexander Köplinger 0f705a4acd Apply API snapshot and csproj changes 2019-04-01 21:51:24 +02:00
Jo Shields f683efc4a6 Merge pull request #13766 from directhex/2019-04
Bump version to 6.2
2019-04-01 11:40:49 -04:00
Jo Shields 7a7bebbfb2 Bump version to 6.2 2019-04-01 10:33:13 -04:00
Filip Navara acb8dd1183 Fix WASM build (#13763)
Broken by https://github.com/mono/mono/pull/13712.
2019-04-01 12:15:50 +02:00
Alexander Köplinger 7c62c3b838 Update API snapshot 2019-04-01 11:33:15 +02:00
monojenkins df0b3ae630 [bcl] Update BCL Linked Size 2019-04-01 08:12:39 +02:00
Marek Habersack acbeffd073 [sdks,mac] Remove dependency on MXE in favor of MinGW
It turns out that homebrew now has a package for the MinGW gcc-based windows
cross compiler which is awesome as it allows us to skip building MXE and use the
latest version of the GCC suite pre-packaged for Mac. This commit removes almost
all traces of MXE (except for `mxe.mk` itself, because I don't know if any bot
or external tool, whatever, use targets in it) and adds the following brew
packages to SDK bot provisioning as well as to the `provision-mxe` target of
Mono SDKs:

  * mingw-w64
  * xamarin/xamarin-android-windeps/mingw-zlib

The latter package builds a Windows version of zlib using MinGW and it comes
from Xamarin's own homebrew tap at https://github.com/xamarin/homebrew-xamarin-android-windeps/blob/f4cc90845ff1953800d8d71035566a12d9b7aa24/mingw-zlib.rb

Additionally, this commit adds a new `configure` flag: `--with-static-zlib=PATH`
which allows one to specify the static zlib archive to use when linking Mono.
The static archive supersedes the otherwise indicated or detected zlib. This is
the recommended mode of operation for MinGW builds as it avoids problems with
`zlib.dll` versions on the target machine.
2019-03-31 11:51:13 -04:00
Filip Navara 9ccfd778e3 [System.Private.CoreLib/mscorlib] Implement Interlocked.MemoryBarrierProcessWide (#13712)
* Implement Interlocked.MemoryBarrierProcessWide

* Bump MONO_CORLIB_VERSION

* Bump API snapshot submodule
2019-03-31 12:08:51 +02:00
Ganbarukamo41 e894d683f9 Implement IEquatable to Memory and ReadOnlyMemory (dotnet/coreclr#23586)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-31 09:51:23 +02:00
Egor Bogatov 282a9635b3 fix IsPinnable 2019-03-31 09:50:09 +02:00
Marcos Cobeña Morián 4747e3c057 Fixed casing (#13736) 2019-03-30 16:53:24 +01:00
Steve MacLean 7ffd5ed8aa Assembly.Load ALC name (dotnet/coreclr#23574)
Use normalized path for ALC name

Signed-off-by: dotnet-bot <[email protected]>
2019-03-30 00:39:00 +01:00
Alexander Köplinger 5cce664b6f Update System.Net.Http for Watch
(cherry picked from commit 4e3ef48ff0)
2019-03-30 00:13:07 +01:00
Alexander Köplinger bb4a72ae3b Bump binary-reference-assemblies
(cherry picked from commit 0366d7da15)
2019-03-29 23:51:52 +01:00
Alexander Köplinger a2462e19e9 [System.Net.Http] Add IVT to Xamarin.* assemblies and update Mac
NSUrlSessionHandler is in Foundation namespace on XM

(cherry picked from commit 5460d8af74)
2019-03-29 23:48:52 +01:00
Marek Safar 4d7931cd0f enable more tests 2019-03-29 23:30:00 +01:00
Marek Safar c302bfdc66 [netcore] Reorder test targets 2019-03-29 23:30:00 +01:00
Marek Safar b3fc4b1263 [System.Private.CoreLib] Adopt delegate to netcore 2019-03-29 23:30:00 +01:00
Marek Safar ec0618dd9e [System.Private.CoreLib] Fix the type conflicts with corefx types 2019-03-29 23:30:00 +01:00
Jo Shields 37a4bd4c08 Fix for OpenBSD scope error in https://github.com/mono/mono/pull/13633 2019-03-29 16:54:26 -04:00
Martin Baulig ccb95fc05f [wasm]: Disable managed collation on wasm. (#13684)
* The `SimpleCollator` class now implements a new internal interface `ISimpleCollator`.
  In `CompareInfo`, we reference it by that interface everywhere except `GetCollator ()`,
  so we can `#if`-def it out.

  Later on, we will use the linker to do this dynamically with some sort of conditional,
  but even then the interface is required to limit references to the `SimpleCollator` type
  to one single method.

* Add `Mono.Globalization.Unicode/SimpleCollator.cs` to `wasm_corlib.dll.exclude.sources`.

* `corlib/Makefile`: remove collation resources on WASM.

* Added new `[Category ("ManagedCollator")]` to the relevant tests.
2019-03-29 21:31:17 +01:00
Aleksey Kliger (λgeek) 20b523ee9c [arm] Don't use C++ keyword as a variable name (#13744)
Fixes the nightly C++ Jenkins jobs
https://jenkins.mono-project.com/job/test-mono-mainline-linux-cxx/
2019-03-29 16:27:49 -04:00
Alexander Köplinger 41672cbc74 Bump binary-reference-assemblies 2019-03-29 19:43:24 +01:00
Alexander Köplinger 15a0b97b10 [System.Net.Http] Move Mac/iOS specific HttpMessageHandler's to Xamarin.*.dll (#13746)
* Revert "[System.Net.Http] Move NSUrlSessionHandler from xamarin-macios to mono (#13229)"

This reverts commit 5bf74a9954.

* [System.Net.Http] Move Mac/iOS specific HttpMessageHandler's to Xamarin.*.dll

We decided to move these types into Xamarin products since they can't be
used without the underlying infrastructure anyway.

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-29 19:27:07 +01:00
Jo Shields 9ebf3a834c Merge pull request #13747 from directhex/dependency_tracking_is_hard
Add missing assemblies needed by Roslyn snapshot
2019-03-29 14:03:40 -04:00
Jo Shields ece0f7cc26 Add missing assemblies needed by Roslyn snapshot 2019-03-29 14:03:06 -04:00
Jo Shields fbc7da2a3f Merge pull request #13633 from rfht/master
Fix DNS Name Resolution Failure on OpenBSD (GitHub issue #8168)
2019-03-29 13:27:48 -04:00
Filip Navara a7a225ceaf [netcore] Guard for skipFrames overflow, update test exclusions (#13745)
* [netcore] Guard for skipFrames overflow

* [netcore] Remove Timer tests exclusion

* [netcore] Remove unnecessary null check
2019-03-29 17:53:52 +01:00
Katelyn Gadd 0de947787c Add missing roslyn assemblies to mcs package makefile (#13738)
* Add missing roslyn assemblies to mcs package makefile

* Remove deploy step for dynamic interface methods prototype since current roslyn has DIM

Roslyn picked up some new dependencies that I failed to add to a Makefile containing a list of its dependencies. This may fix some scenarios (not covered by CI) that result in csc and/or msbuild not working.
2019-03-29 16:39:11 +01:00
Koundinya Veluri 3eef668848 Change Timer implementation on Unixes to use only one scheduling thread (#7071)
* Change Timer implementation on Unixes to use only one scheduling thread

- Separated from https://github.com/dotnet/corert/pull/7066

* Address feedback from https://github.com/dotnet/corert/pull/7066

* Remove reference to s_lock

* Reduce work inside lock

* Move _id

* Fix duplicate timers in scheduled timer list, move info to TimerQueue

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 15:21:46 +01:00
Egor Bogatov 8cce577994 Update tests 2019-03-29 14:56:22 +01:00
Filip Navara 7ea8460025 Make the DnsTest more resilient to multi-IP DNS results (#13737)
Sometimes Google DNS is/was returning "dns.google" for reverse query of 8.8.8.8 and 8.8.4.4 instead of the expected "google-public-dns-a.google.com" and "google-public-dns-b.google.com". Since "dns.google" resolves to both 8.8.8.8 and 8.8.4.4 in random order the round-trip tests for IP -> hostname -> IP were failing when they got the other IP.

This changes the logic in the hostname -> IP check to check whether the expected IP is any one of the returned ones (ie. non necessarily the first one).
2019-03-29 14:54:49 +01:00
Tanner Gooding 40532637b9 Updating BuildTools, CoreCLR to preview4-03828-01, preview4-27528-71, respectively (#23536)
* Removing FeedTasksPackageVersion from dependencies.props
* The corresponding metadata was removed in https://github.com/dotnet/coreclr/pull/22884

* Updating BuildTools, CoreCLR to preview4-03828-01, preview4-27528-71, respectively

* Adding a ! in String.Searching.cs

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 14:46:41 +01:00
Zoltan Varga 77e99d080d [netcore] Ongoing work. (#13731) 2019-03-29 12:47:16 +01:00
Ben Adams 20c9bdc20a Avoid boxing allocations for async in Tier0 (dotnet/coreclr#22984)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Marek Safar afb35526cf Simplify StackFrame class (dotnet/coreclr#23483)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Jan Kotas 9d354a7332 Delete RuntimeThread.cs (dotnet/coreclr#23532)
No longer needed

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Levi Broderick e2c52c86d3 Improve performance of Marvin32 (dotnet/coreclr#22816)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 08:04:23 +01:00
Sung Yoon Whang 419b334239 Fix increment calculation in IncrementingPollingCounter (#23502)
* Add test for IncrementingPollingCounter

* Fix a bug in Increment calculation in IncrementingPollingCounter

* Remove setting DisplayName property since that's a private property for now

* fix comment

* Remove unused variables

Signed-off-by: dotnet-bot <[email protected]>
2019-03-29 07:56:07 +01:00
Santiago Fernandez Madero cbf08f3dd6 Nullable: System.Object (dotnet/coreclr#23466)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 20:17:41 +01:00
Krzysztof Wicher b2e00ef754 Nullable: all calendars (dotnet/coreclr#23469)
* calendar

* nullable: all calendars

* fix likely corert error

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 20:17:41 +01:00
Santiago Fernandez Madero bc096b344f Nullable: System.Char (dotnet/coreclr#23480)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 20:17:41 +01:00
Egor Bogatov 2522547cd5 [netcore] Improve xtest command (#13703)
The python script now also extracts downloaded zips and `make xtest-%` is now able to consume these artifacts.
E.g.
```
make xtest-System.Collections.Tests COREFX_ROOT=/prj/corefx-repo
```
We still need COREFX_ROOT because of two missing files:
`CoreFx.Private.TestUtilities.dll` and `xunit.console.deps.json`
maybe I should just add them to our repo?

Also this PR fixes `RemoteExecutorConsoleApp` problems for `make xtest-%`
2019-03-28 18:00:34 +01:00
Larry Ewing 49ba9f32ec Merge pull request #13705 from kjpou1/wasm-issue-12871
[wasm] Fix System.DllNotFoundException: libc
2019-03-28 11:44:43 -05:00
Alexander Köplinger f48b0a70c3 [Mono.Runtime.Tests] Remove duplicate file in .sources 2019-03-28 16:40:07 +01:00
simplejackcoder e3471b915d GetPinnableReference on String.cs (dotnet/coreclr#23428)
* GetPinnableReference on String.cs

* Add attributes for debugger and performance

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 16:31:00 +01:00
Jo Shields 7e99ce2960 Merge pull request #13700 from directhex/compress-with-xz
Switch `make dist` format from BZip2 to XZ.
2019-03-28 11:22:09 -04:00
Radek Doulik 4cf13bcd16 [profiler] Add duration=NUM parameter to AOT profiler (#13688)
* [profiler] Add duration=NUM parameter to AOT profiler

It instructs the AOT profiler to write the data after NUM seconds
measured from runtime initialization.

* [profilers] Added aot:duration=NUM parameter description
2019-03-28 10:54:36 -04:00
Alexander Köplinger c6b066a7ab Bump corefx to get unit test reliability fix (#13709) 2019-03-28 15:46:21 +01:00
Jo Shields ac0f7ece35 Merge pull request #13699 from directhex/no-more-monograph
Delete monograph. Closes https://github.com/mono/mono/issues/7845
2019-03-28 10:18:53 -04:00
Maxim Lipnin 03e3608b87 Move checks for empty command text to SqlCommand 2019-03-28 15:02:24 +01:00
Maxim Lipnin b1a0ee371a Throw ArgumentException if there is no active statement during reading a row 2019-03-28 15:02:24 +01:00
Filip Navara 8f99674718 Update Makefile 2019-03-28 14:36:07 +01:00
Filip Navara 141493c473 Separate out common code from pinvoke_probe_for_module_relative_directories into pinvoke_probe_for_module_in_directory 2019-03-28 14:36:07 +01:00
Filip Navara 4648210f3b [netcore] Move P/Invoke directory lookup from mono_dl_fallback to pinvoke_probe_for_module_relative_directories 2019-03-28 14:36:07 +01:00
Filip NavaraandAleksey Kliger 3e05b4ea77 [netcore] Handle NATIVE_DLL_SEARCH_DIRECTORIES for p/invoke
Co-authored-by: Aleksey Kliger <[email protected]>
2019-03-28 14:36:07 +01:00
Jan Kotas 8bad65acb8 Move QueryPerformanceCounter PInvokes to shared (dotnet/corefx#36409)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
buyaa-n e76b69f37b Nullable updates for byte type (dotnet/coreclr#23460)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
buyaa-n 1feba9a019 Nullable changes for boolean type (dotnet/coreclr#23451)
* Nullable changes for boolean type

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Santiago Fernandez Madero 6b79fcecc8 Nullable: String (dotnet/coreclr#23450)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Krzysztof Wicher 6ac3ca34e7 nullable: number (dotnet/coreclr#23454)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Krzysztof Wicher c0f4d63fa0 Nullable: Uint32, (U)Int16, (U)Int64 (dotnet/coreclr#23449)
* Nullable: UInt32

* (U)Int16, (U)Int64

* Make NumberFormatInfo non-nullable

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Krzysztof Wicher 23b6018c77 Nullable: Int32 (dotnet/coreclr#23443)
* Nullable: Int32

* remove restore and move nullable up front

* remove trailing \n after #nullable to make it easier to remove later

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Steve MacLean dae859e9e2 ALC Enhancement nits (dotnet/coreclr#23506)
isCollectible default should be false
String should be string

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:13:48 +01:00
Steve MacLean ea3b4ae05f ALC enhancements (dotnet/coreclr#22273)
* Initial implementatation of ALC enhancements

Add public constructor with name
Add Name property
Add Assemblies property
Add All property
Override ToString
Name Default and Assembly.Load(...) ALCs
Add AssemblyLoadContext30Extensions test

Signed-off-by: dotnet-bot <[email protected]>
2019-03-28 14:02:28 +01:00
Vlad Brezae 23aa609af7 [interp] Small changes (#13691)
* [interp] Extract the code pushing lmf in separate function

There is no reason to not optimize the code inside do_icall

* [interp] Remove dead code

Trace ips are filled in mono_handle_exception_internal
2019-03-28 13:12:17 +01:00
Zoltan Varga 34f3b8947c [llvm] Fix the computation of size of gshared instances in another place.
Fixes https://github.com/mono/mono/issues/13610.
2019-03-28 13:07:45 +01:00
Filip Navara d261a9ace1 [netcore] Implement missing functions in RegisteredWaitHandle and EventWaitHandle 2019-03-28 08:30:20 +01:00
Jay Krell 83acc1a343 Restore domain in error path. (#13662)
* In mono_threadpool_enqueue_work_item, if mono_runtime_invoke_checked fails,
still restore domain.

In mono_threadpool_enqueue_work_item, acknowledge with a comment but do not change
that mono_domain_set failing leads to returning success.

In mono_threadpool_enqueue_work_item, refactor for sharing code without loss
of efficiency or hopefully clarity.

* Keep this line duplicated:
`mono_runtime_invoke_checked (unsafe_queue_custom_work_item_method, NULL, args, error);`
2019-03-28 02:20:53 -04:00
Jay Krell 3fae397cce Cleanup mono_marshal_get_icall_wrapper (#13661)
Every caller was consistently forming the same name based on callinfo->name
and passing callinfo->func and callinfo->sig.
Pass callinfo instead and do the common work in mono_marshal_get_icall_wrapper.

This has the following side effects:
 Do not form and free name when there is a cache hit. This seems like a nice optimization.
 Allow name when there is a cache hit. This is unintended. We could assert if it is a problem.
2019-03-28 02:20:35 -04:00
Kenneth Pouncey 4904dac430 [wasm] Fix System.DllNotFoundException: libc
Fixes issue: https://github.com/mono/mono/issues/12871
2019-03-28 06:42:10 +01:00
Zoltan Varga 5433bd030e [runtime] Revert daf92b9e62. (#13696)
Fixes https://github.com/mono/mono/issues/13607.
2019-03-27 23:46:43 +01:00
Jo Shields a9c340a063 Switch make dist format from BZip2 to XZ.
Closes https://github.com/mono/mono/issues/9267
2019-03-27 15:50:25 -04:00
Jo Shields 38fdb39cac Delete monograph. Closes https://github.com/mono/mono/issues/7845 2019-03-27 15:45:06 -04:00
Alexander Köplinger 77cf4cc4f8 [tests] Remove MONOMAC ifdef from BCL tests (#13694)
It was set by xamarin-macios when they were still taking the raw .cs source files
but since we switched to prebuilt binaries we need to replace it with
some define we're actually setting in Mono.

Most cases can be replaced by just XAMMAC_4_5 since MOBILE is defined on the xammac profile.
2019-03-27 20:21:48 +01:00
Jo Shields e40d76cb4a Merge pull request #13673 from directhex/runtime-nupkg
Runtime nupkg generation
2019-03-27 14:39:17 -04:00
Alexander Köplinger e8c660ce90 [mono] Don't try "open" handlers on iOS/Android in ves_icall_System_Diagnostics_Process_ShellExecuteEx_internal (#13693)
When you use `Process.Start()` with `UseShellExecute=true` (which is the default on Mono/.NET Framework, but false on .NET Core) then we'd still try to first start the file directly, before falling back to trying the "open" handlers like xdg-open to launch the file.

Presumably we do this so that on mobile you can still start a process without needing to explicitly set `UseShellExecute=false`.

However we don't need to try the fallback on iOS/Android since the "open" handlers won't work there anyway.

This recently showed up on the Xamarin.iOS Mono 2019-02 integration where we started running the `System.Diagnostics.ProcessTest` suite and the `Start1_FileName_NotFound()` would fail at `#C6` because the native error code wasn't 2 (file not found) but 13 (invalid data). This is because it tried
to use `/usr/bin/open` which doesn't work of course so it got to the `mono_w32error_set_last (ERROR_INVALID_DATA)` on L2088.
2019-03-27 19:11:48 +01:00
Jo Shields a48e2c8e10 Add some RID detection, and use it to allow runtime nupkg generation
We cannot presume more than just "linux" or "osx" in our RIDs, because
if we want to enable --host vs --build, we can't detect the OS from
the runtime environment.

This is an okay compromise for now.
2019-03-27 10:28:50 -04:00
Jo Shields 7f04ffa847 Add possibility of generating a runtime .nupkg for Mono (Mac-only right now) 2019-03-27 10:28:50 -04:00
Filip Navara 7a74f15949 [netcore] Fix stack size for new threads 2019-03-27 15:23:59 +01:00
Marek Safar fdc4920d5f [System.Private.CoreLib] Implement exceptions capturing 2019-03-27 15:22:50 +01:00
Maxim Lipnin a9f3b8ca54 Port 13553 "Fix transition offset logic" to master 2019-03-27 14:57:03 +01:00
Filip Navara c45f622d97 [netcore] Fix thread debugging messages 2019-03-27 14:33:54 +01:00
Tanner Gooding e658a7d478 Cleaning up the P/Invoke signatures for QPF and QPC to avoid marshalling and pinning (#36071)
* Cleaning up the P/Invoke signatures for QPF and QPC to avoid marshalling and pinning

* Responding to PR feedback.

* Dropping support for low resolution stopwatch

* Removing BestFitMapping=false

* Removing unneeded unsafe declarations

* Addressing more PR feedback

* Fixing the pal_time header file

* Fixing the Unix P/Invoke signatures for GetTimestamp and GetTimestampResolution to return ulong.

* Fixing GetTimestampResolution to scale the result for HAVE_CLOCK_MONOTONIC

Signed-off-by: dotnet-bot <[email protected]>
2019-03-27 14:32:40 +01:00
lateralusX b98013086e Fix incorrect use of FreeHGlobal on Marshal UTF8 allocated string. 2019-03-27 14:23:44 +01:00
Zoltan Varga c7d6919ceb [netcore] Download test assets from the dotnet-core blob feed. 2019-03-27 14:22:41 +01:00
sancheolz a68389fe9a Fix NRE when combobox was disposed and Text set (#13665)
If combobox already was disposed and we setting Text field there will be NullReferenceException. On .net winforms there no excetions.
2019-03-27 13:02:56 +01:00
Alexander Köplinger 1bc213fac1 [System.Xml] Don't hardcode nunit-lite-console in GeneratedCodeAttribute
Instead determine it at runtime.
2019-03-27 11:39:22 +01:00
Alexander Köplinger 5602acf399 [corlib] Skip FileTest.LastWriteTimeSubMsCopy on older iOS Simulators (#13681)
When we switched to using the corefx System.IO.File implementation we also switched to an implementation that uses the `copyfile()` standard library call on macOS/iOS to copy files. This should preserve file metadata such as timestamps.

However there's a small edge case: when using an older version of the iOS Simulator < 11.0 the `copyfile()` call doesn't copy sub-second timestamps, presumably because older iOS ran on HFS which doesn't support that.
When we run this simulator on modern macOS which uses APFS and thus supports sub-second timestamps the origin file used for the test _does_ have sub-second timestamps and the test would fail.

We now skip the test in such environments.

PS: why did this not fail with the old Mono implementation? We used to always call utimes() on the destination file after copying to copy metadata, which in turn would update the file in the simulator host.
It doesn't seem worth it to replicate that behavior for this small edge case.
2019-03-27 11:26:16 +01:00
Katelyn Gadd e9d847d0f6 Bump roslyn binaries to 3.1.0 and add VBCSCompiler.exe to the set of paths auto-detected by configure.ac (#13518)
* Reconfigure bump for PR test

* Actually bump submodule this time probably

* Bump submodule

* Revert "Bump submodule"

This reverts commit b47679be10d3c38d40673cf73e0dc48a300318bc.

* Bump submodule

* Modify csi-test.csx to manually reference netstandard 2.0, because this is required for some reason

* Checkpoint: Test modifying csi.rsp instead of csi-test

* Git

* Update submodule

* Update submodule compiler path

* Remove binaries-new submodule

* Update to latest roslyn-binaries revision and update path in configure.ac
2019-03-27 09:17:24 +01:00
Zoltan Varga 4bb8637454 [netcore] Fix some thread failures. 2019-03-27 09:15:45 +01:00
Zoltan Varga de89d6dc77 [netcore] Fix ArgumentException argument order. 2019-03-27 09:15:45 +01:00
Zoltan Varga 593853ef06 [netcore] Disable boehm. 2019-03-27 09:15:45 +01:00
Martin Baulig 1af992a5ff Split AppDomain.DoTypeResolve(object) into DoTypeResolve() and DoTypeBuilderResolve(). (#13142)
* Instead of having one `AppDomain.DoTypeResolve(object)` that checks at runtime whether
  the argument is a `string` or a `TypeBuilder`, use two strongly-typed methods
  `DoTypeResolve(string)` and `DoTypeBuilderResolve(TypeBuilder)`.

* Add both to the `corlib/LinkerDescriptor/mscorlib.xml`.

* Adjust the code in `appdomain.c` accordingly.

* Bump corlib version.

This is part of a larger on-going project to improve the linker logic.

The rationale behind this is that the new `AppDomain.DoTypeResolve(string)`
that is being called from `mono_domain_try_type_resolve_name()` should not
reference `TypeBuilder`, to allow the linker to remove some of the
`System.Reflection.Emit` types.
2019-03-27 01:51:38 -04:00
Jay Krell 636160148f Cleanup double semi-colons. (#13660)
Cleanup double semi-colons.
2019-03-26 23:45:42 -04:00
Filip Navara fea837d6d3 Fix sample path 2019-03-26 20:47:21 +01:00
Filip Navara b9b6923a58 Exception stack trace should be null when not thrown yet 2019-03-26 20:47:21 +01:00
Marek Safar 06cdc67e2f [System.Private.CoreLib] Implement StackTrace construction from current thread 2019-03-26 19:52:00 +01:00
Egor Bogatov 2f1c1d3b2c [netcore] Implement Array.Sort (#13674)
* Update Array.cs

* implement Array.Sort
2019-03-26 18:10:23 +01:00
Martin Baulig 22073ed676 Cosmetic: remove accidentally added gensources debugging flag. (#13678) 2019-03-26 18:02:55 +01:00
Bernhard Urban 5e70d5ee51 [intrinsics] sync implementation with IL code (#13647)
* [intrinsics] sync implementation with IL code

Before the intrinsic implemented
```
ldarg.0
ldarg.1
sizeof !!T
mul
conv.i
add
ret
```

now it implements
```
ldarg.0
ldarg.1
sizeof !!T
conv.i
mul
add
ret
```

`conv.i` and `mul` have been swapped. Also see https://github.com/mono/mono/pull/13609

* fix op_sext_i4 usage
2019-03-26 12:30:18 -04:00
Zoltan Varga 9d652a972a [llvm] Fix the computation of size of gshared instances in emit_args_to_vtype (). (#13659)
Fixes https://github.com/mono/mono/issues/13610.
2019-03-26 16:28:59 +01:00
Filip Navara e7011c780f Convert from ucontext_t (or platform equivalent) to MonoContext early and propagate it through 2019-03-26 10:56:49 +01:00
Filip Navara 69abf8f5e4 Preserve the native crash context instead of MonoContext to allow printing managed stack trace later 2019-03-26 10:56:49 +01:00
Filip Navara d8e53c515d [netcore] Change loader behaviour to disable assembly remapping and allow loading newer assembly versions 2019-03-26 09:03:04 +01:00
Marek Safar 86506fbdbd [System.Private.CoreLib] Implement StackFrame initialization 2019-03-26 08:39:15 +01:00
Larry Ewing ed2d3504d6 Merge pull request #13620 from kjpou1/wasm-misc-cleanup
[wasm] Remove specific link to framework file when building test-suite
2019-03-25 13:55:51 -05:00
Bernhard Urban 64e17113b2 [amd64] use 32bit variant of lea_membase for 32bit operations (#13642)
[amd64] use 32bit variant of lea_membase for 32bit operations

Consider
```
 xor %r15, %r15       // %r15 = 0x0
 dec %r15d            // %r15 = 0xffff_ffff
 lea 0x1(%r15), %rdx  // %rdx = 0x1_0000_0000 but should be 0x0
```

instead `lea 0x1(%r15), %edx` should be generated.


Fixes #13452
Fixes #13597
2019-03-25 14:25:43 -04:00
Larry Ewing 05a40c67ea Merge pull request #13636 from kjpou1/wasm-add-bindings
[wasm] [packager] Remove the unnecessary call to add_bindings()
2019-03-25 12:13:01 -05:00
Egor Bogatov e653d48b3a [netcore] Improve xunit console runner (#13648)
* improve xunit runner

* improve xunit runner
2019-03-25 16:40:42 +01:00
Larry Ewing 478656ff1d Merge pull request #13416 from kjpou1/wasm-websocket-tests
[wasm][tests] Add WebSocket tests
2019-03-25 09:12:29 -05:00
Zoltan Varga 1fb3b3b87d [netcore] Add System.Reflection.Emit support. (#13613) 2019-03-25 15:04:36 +01:00
Marek Safar 48b8f5ce47 Revert "Do not use MAP_JIT by default, instead make this something that is toggled by Xamarin.Mac which needs it"
This reverts commit a4c8606767.
2019-03-25 14:56:41 +01:00
Johan Lorensson cae256c3b0 Merge pull request #13571 from lateralusX/lateralusX/add-utc-timezone-on-fallback
Add UTC timezone in WinRT GetSystemTimeZones fallback implementation.
2019-03-25 09:30:47 -04:00
Jay Krell 8feaad70f0 Remove const on struct fields. (#13624)
It is unusual and not useful.
2019-03-25 08:36:38 -04:00
Miguel de Icaza a4c8606767 Do not use MAP_JIT by default, instead make this something that is toggled by Xamarin.Mac which needs it 2019-03-25 12:00:41 +01:00
Johan Lorensson 1ff137d950 Merge pull request #13572 from lateralusX/lateralusX/change-test-spincount
Increase spin-count on test to not end up in frequent sleeps on multicore machines.
2019-03-25 06:48:41 -04:00
Kenneth Pouncey 85d86d2215 [wasm] Remove the unnecessary call to add_bindings() when runtime.js is generated. 2019-03-25 11:38:28 +01:00
Jay Krell 004314e9dd [windows]Fix and cleanup configure.ac parsing for MONO_CORLIB_VERSION and ACINIT. (#13630)
Not just a guid or an uppercase guid.
2019-03-25 10:55:15 +01:00
Bernhard Urban eb1cb188a6 [interp] fix "This greater-than-or-equal-to-zero comparison of an unsigned value is always true" reported by Coverity (#13625)
[interp] fix "This greater-than-or-equal-to-zero comparison of an unsigned value is always true" reported by Coverity
2019-03-25 05:45:59 -04:00
Egor Bogatov ac2fb76ed0 [netcore] Marshal.IsPinnable (#13628)
Needed for MSBuild.
Stream changes were copied from [CoreRT](https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/IO/Stream.CoreRT.cs).
IsPinnable - perhaps it should be an icall/intrinsics for better perf?
[CoreCLR impl for IsPinnable (InternalCall)](https://github.com/dotnet/coreclr/blob/1f3f474a13bdde1c5fecdf8cd9ce525dbe5df000/src/vm/marshalnative.cpp#L257)
[CoreRT impl for IsPinnable](https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.cs#L114) (and [MightBeBlittable](https://github.com/dotnet/corert/blob/master/src/System.Private.CoreLib/src/System/Runtime/InteropServices/InteropExtensions.cs#L60))
2019-03-25 10:22:54 +01:00
Nick Schonning 47cc95bbb6 typo: Double word "both" (dotnet/corefx#36272)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 65b123d5e9 typo: Double word "never" (dotnet/corefx#36300)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning f1bde8bbaa typo: Double word "to" (dotnet/corefx#36264)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 659cf556ef typo: Double word "that" (dotnet/corefx#36269)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 83133240dc typo: Double word "a" (dotnet/corefx#36271)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 2a659f1cda typo: Double word "in" (dotnet/corefx#36270)
* typo: Double word "in"

* Update src/System.Console/src/System/Console.cs

Co-Authored-By: nschonni <[email protected]>

Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 0f3c093b09 typo: Double word "the" (dotnet/corefx#36274)
* typo: Double word "the"

* Apply suggestions from code review

Co-Authored-By: nschonni <[email protected]>

Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 0719b0209c typo: Double word "this" (dotnet/corefx#36273)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 4b2c08e01b typo: Double word "are" (dotnet/corefx#36275)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 42199a6297 typo: Double word "types" (dotnet/corefx#36276)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 84bc77cabf typo: Double word "is" (dotnet/corefx#36283)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Nick Schonning 32c4104e44 typo: Double word "we" (dotnet/corefx#36288)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 09:44:44 +01:00
Egor Bogatov b3287d7157 [netcore] Semaphore (#13627)
* Update Semaphore.cs

* netcore Semaphore

* Update Semaphore.cs
2019-03-25 08:51:52 +01:00
Nick Schonning 21b1ee3b62 typo: Double word "as" (dotnet/corefx#36277)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-25 08:34:52 +01:00
Jay Krell fd1baed2af Remove the parsing, hashing, locking, allocations associated with JIT icall signatures. (#13579)
* Remove the parsing, hashing, locking, allocations associated with JIT icall signatures.
Make them statically allocated, single-instanced at compile time, and almost
statically initialized.

Fix C++ and x86.

More x86 fix.

Fix ARMv5.

Undo tedious work to be redone instead of merged from old.

Put all signatures back, prepare for automated conversion.

Replace all the register_icall strings with:

my @a = ("double double",
"long long long",
"long long int32",
"double double double",
"ulong float",
"ulong double",
"long float",
"double int32",
"float float float",
"long double",
"object ptr int int32",
"double ptr",
"int int int ptr ptr ptr",
"int obj ptr",
"int obj",
"int ptr int int ptr object",
"int32 double",
"int32 int32 int32",
"int32 int32 ptr",
"int32 obj",
"int32 object ptr ptr ptr",
"int32 object",
"int32 ptr ptr ptr ptr ptr int32",
"int32 ptr ptr",
"obj ptr int",
"obj ptr",
"object int object object",
"object int object",
"object int",
"object int32",
"object object ptr ptr",
"object object ptr",
"object object",
"object ptr int int int int",
"object ptr int int int",
"object ptr int int",
"object ptr int ptr",
"object ptr int",
"object ptr int32",
"object ptr ptr int32",
"object ptr ptr ptr ptr ptr",
"object ptr ptr",
"object ptr",
"object",
"ptr int",
"ptr obj",
"ptr object int ptr ptr",
"ptr object int32 int32",
"ptr object ptr ptr",
"ptr object ptr",
"ptr object",
"ptr ptr int ptr",
"ptr ptr int",
"ptr ptr int32",
"ptr ptr ptr ptr",
"ptr ptr ptr",
"ptr ptr",
"ptr",
"uint32 double",
"uint32 ptr int32",
"void double ptr",
"void int",
"void int32",
"void obj ptr",
"void object object ptr",
"void object object",
"void object ptr int32 int32",
"void object ptr int32",
"void object ptr",
"void object",
"void ptr int int object",
"void ptr int object",
"void ptr int ptr",
"void ptr int",
"void ptr int32",
"void ptr object int32",
"void ptr ptr int",
"void ptr ptr int32",
"void ptr ptr ptr",
"void ptr ptr",
"void ptr",
"void ptr object",
"void",
);

while (my $line = <>)
{
	if ($line =~ /register|mono_create_icall_signature/ && $line =~ /"/)
	{
		for my $from (@a)
		{
			my $to = "mono_icall_sig_$from";
			$to =~ s/ /_/g;
			$to =~ s/"//g;
			$to =~ s/"//g;
			$to =~ s/"//g;
			$line =~ s/\Q"$from"\E/$to/;
		}
	}
	print($line);
}

Remove whitespace from end of line.

Convert the strings to smaller arrays, of chars now,
that are scaled offsets into MonoDefaults, or -1 for ptrref.

Use smaller encoding.

fix merge

cleanup

* Larger representation that handles alignment.

* Try to undo external changel.

* Fix AOT.

* Fix code search and comments

* Restore warning in this PR.

* More ARM signatures.

* Change representation from pointer to offset.
  Use sizeof for the special case ptrref.
Comments. Perhaps too much.
asserts. Perhaps too much.
A little bit more verbose/readable but essentially the same thing otherwise.
 Perhaps too verbose.

* The initializer all-but-must be pointer-sized.
Even if the values fit in much smaller.
Add comments.
On obscure systems size_t is smaller than a pointer so
gsize or uintptr_t is required. Use gsize.

* Spaces before parens.

* PR: Use enum instead of offsetof.
Use may_alias some.
mono builds with -fno-strict-aliasing, but we had recent
aliasing problem (the enum operators with older g++)
and this looks a little hazardous

We could also have a separate integer or array of byte or array of integer or perhaps string
to resolve the aliasing.

integer: 16 values, 8 max -- could just use an int instead of this array business,
but the representation would be full with no room for expansion.
We are not wasting any/much memory here -- maybe one word per the 200 signatures,
because of sloppyness around any_size_array.

Work a little on dealiasing.
Comment some aliases and make obj/object, int/ptr, bool/boolean share values.

* tweak: Compute all the values once and then directly index small local array.

* Adjust comments to new reality.
Add comments explaining aliasing.

* Add casts to attempt to abide by strict aliasing rules.
2019-03-24 23:16:32 -04:00
thfrwn 6d3aa51dd3 Fix DNS Name Resolution Failure on OpenBSD (GitHub issue #8168) 2019-03-24 17:10:22 -07:00
Kenneth Pouncey 5e61de3a2c Modify packager to load the .pdb files for framework packages. (#13608) 2019-03-24 08:33:27 +01:00
リーフストーム 0b58483fa8 Fix handle leak in cominterop (#13536) 2019-03-23 15:15:57 -04:00
Alexander Köplinger d4953f63ca [sdks] Easier labels for pipeline parts 2019-03-23 10:42:42 +01:00
Alexander Köplinger afdf77b053 [sdks] Build Android Linux Mono SDKs package on CI 2019-03-23 10:30:45 +01:00
Levi Broderick 6ddc22cefe Replace slow implementations in ASCIIUtility with fast implementations (#22516)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-23 09:56:52 +01:00
Jérôme Laban 5134c0fec6 Include the corebindings.c in the package output (#13606)
This update restores the ability to use the packager outside of the mono source tree.
2019-03-23 07:11:01 +01:00
Alexander Kyte 0eac33443d [runtime] Add MONO_LLVM_INTERNAL to *get_aot_init_wrapper* marshal funcs (#13611) 2019-03-23 01:36:58 -04:00
Kenneth Pouncey 1b7c7561ab Remove specific link to framework file when building test-suite 2019-03-23 05:32:51 +01:00
Tarek Mahmoud Sayed 612c1b9f42 Apply Optimization in Index.GetOffset suggested by Levi (#23349)
* Apply Optimization in Index.GetOffset suggested by Levi

* Add Comment

* address the feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 23:30:09 +01:00
Marek Safar 871975de4e Adopt to shared Exception 2019-03-22 23:27:38 +01:00
Marek Safar 7541d7e5fb Move Exception to shared partition (dotnet/coreclr#23361)
* Move Exception to shared partition

* Remove class name caching

* Not useful comments removal

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 23:27:38 +01:00
Andrew Hoefling 8fe79b4c8e Updated Exception Handling for Collection<T> (dotnet/coreclr#23290)
* Updated Argument Helper param from list->collection since the parameter name is collection

* Updated exception message to use an out of range exception that doesn't explicitly reference a list

* Simplified if statements that verify if the index is out of range

* Updated if logic to be simplified using (uint)

* Updated exception handling to throw ThrowHelper.ThrowArgumentOutOfRange_IndexException() when the ExceptionArgument was 'Index'

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 23:27:38 +01:00
Thays Grazia 4abc661805 [DIM] Method call of a class that implements a protected nested interface (#13558)
* Unexpected System.MethodAccessException is thrown for a method call of a class that implements a protected interface inside another interface.

```
public interface I1
{
    protected interface T1
    {
        void M1();
    }

    protected class T2
    {}

    protected struct T3
    {}

    protected enum T4
    {
        B
    }
}

class Test1 : I1
{
    static void Main()
    {
        I1.T1 a = new Test2();
        a.M1();
        System.Console.WriteLine(new I1.T2());
        System.Console.WriteLine(new I1.T3());
        System.Console.WriteLine(I1.T4.B);
    }

    class Test2 : I1.T1
    {
        public void M1()
        {
            System.Console.WriteLine("M1");
        }
    }
}
``


Fixing this case Test1 implements I1<int> but can access methods from I1<object>
public interface I1<X>
{
    protected interface T1
    {
        void M1();
    }

    protected class T2
    {}

    protected struct T3
    {}

    protected enum T4
    {
        B
    }
}

class Test1 : I1<int>
{
    static void Main()
    {
        I1<object>.T1 a = new Test2();
        a.M1();
        System.Console.WriteLine(new I1<object>.T2());
        System.Console.WriteLine(new I1<object>.T3());
        System.Console.WriteLine(I1<object>.T4.B);
    }

    class Test2 : I1<object>.T1
    {
        public void M1()
        {
            System.Console.WriteLine("M1");
        }
    }
}
2019-03-22 18:37:16 -03:00
Marek Safar 1a4014dbc0 Move Buffer constants to platform specific files (dotnet/coreclr#23352)
* Move Buffer constants to platform specific files

* Add explicit access modifier

Signed-off-by: dotnet-bot <[email protected]>
2019-03-22 21:57:24 +01:00
Aleksey Kliger (λgeek) d465a7ad65 [aot] cleanup MonoError in add_extra_method_with_depth (#13605)
I missed something in the code review for #13581.  Need to cleanup MonoError if it's not ok.
2019-03-22 21:24:56 +01:00
Egor Bogatov e72d6d9e1c [netcore] Implement missing bits in Mutex (#13591)
Needed for xunit console runner tool.
2019-03-22 18:54:20 +01:00
Zoltan Varga b4f4acc133 [aot] Avoid an assert which can happen in normal usage. (#13581)
Fixes https://github.com/mono/mono/issues/13455.
2019-03-22 16:02:15 +01:00
Alexander Köplinger c8508e56b6 [ci] Build macOS .pkg PR builds on a separate bot (#13600)
This allows us to get faster results.
2019-03-22 15:19:24 +01:00
Alexander Köplinger a766d2e802 Bump linker to latest master (#13594)
* Bump linker to latest master

The linker source were reorganized a little bit, e.g. sources in src/

* [csproj] Update project files
2019-03-22 10:10:08 +01:00
Vlad Brezae 216e4aa405 [interp] Make transform phase more flexible (#13516)
* [interp] Fix instruction length

* [interp] Don't generate directly into linear code stream

Allocate each instruction into the mempool and link them together. At the end of code generation and after all potential optimisation passes, we will compact this code into its final form.

* [interp] Add support for branch relocations

For each branch instruction, we store in its data field the il offset that we are branching to. During the final code generation, we resolve all backward branches and add relocs for forward branches. These relocs are then resolved after all instructions have been emitted in the final code stream.

* [interp] Extract vararg call code in separate instruction

It requires a different instruction size and is extremely rare code.

* [interp] Fix backwards branch with large offset

We were adding an unsigned instead of subtracting.

* [interp] Fix line numbers

For each il offset that generated interpreter instructions we store the native offset, during the compaction phase.

* [interp] Fix seq points

We have to defer SeqPoint data creation during the compact generation phase, because that's when we have native offset information. We add a flags field to the interpreter instruction to store any relevant information coming from the compilation phase.

* [interp] Make verbose logging a bit nicer

We no longer have the native offset during the first IL instruction interation. Maybe we should bring back logging for the IL -> IR mapping during the compaction phase.

* [interp] Remove some dead code
2019-03-22 10:06:10 +02:00
Kenneth Pouncey 31cb0e28a5 Fix indentation to address review comments 2019-03-22 05:13:12 +01:00
Jo Shields 21cfdbe81c Make test runner able to deal with whitespace patterns other than newline (#13587)
Helix wasn't running our runtime tests as expected, because the test runner expected newline-separated tests to run, and we were generating space-separated.

Following "be liberal in what you accept" philosophy, and to prevent this issue in the future, just deal with "whitespace separated" rather than "this specific whitespace and no other"
2019-03-22 00:23:28 +01:00
Alexis Christoforides c803e6f75b Xamarin.Android integration fixes (#13589)
Backport of #12940.

- Disable other failing tests (they are tests that are newly added, not regressions)
- Look for mono_pal_init() directly in the System.Native library
- [configure] Have libmono-native depend on libmono(-sgen) for the Android build
If this is not done, Android is not able to resolve mono symbols that are used in mono-native (e.g. mono_add_internal_call_with_flags), and will refuse to load the library with 'cannot locate symbol' errors
2019-03-22 00:15:08 +01:00
Egor Bogatov 0fc15b168f [netcore] Xunit console runner (#13592)
* xunit console runner

* add more xunit args

* use rsp file
2019-03-21 23:43:48 +01:00
Zoltan Varga 53bef4aec4 [llvmonly] Add gsharedvt in wrappers to calls which could go to the interpreter. (#13548)
[llvmonly] Add gsharedvt in wrappers to calls which could go to the interpreter.

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




<!--
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
-->
2019-03-21 15:56:06 -04:00
Vlad Brezae 8423f0e9a0 [interp] Enable compile all debug option also on interp (#13570)
[interp] Enable compile all debug option also on interp
2019-03-21 12:05:48 -04:00
Kenneth Pouncey 2b37e1c0b5 Add tests for send and receive of text and binary messages. 2019-03-21 16:37:36 +01:00
Johan Lorensson 7e8d4303fa Couple of fixes to LLVM AOT compiler on Windows x64. (#13474)
* Enable MSVC objects on LLVM >= 6.00
* Always used PIC relocation-model on Windows x64 due to LLVM problem with
static triggering incorrect ADDR32 relocation entries in 64-bit objects.
* Add CodeView symbol format instead of DWARF for Windows x64.
* Fix LLVM outfile when doing static link to not end up in temp directory.
* Only add /DEFAULTLIB when using MSVC and not doing static compile. For
static compile the needed libraries must be added when objects get's linked
and since the needed libraries are c-runtime libraries, should be transparent
for most applications consuming the object files.
2019-03-21 10:05:01 -04:00
Kenneth Pouncey 6513fffcd7 Add tests for
- Client Close
- Host Close with CloseStatus and CloseStatusDescription filled in from Host.
2019-03-21 14:22:31 +01:00
Bernhard Urban 5852d1cf74 [arm] respect potential spilling for overflow flag check (#13564)
[arm] respect potential spilling for overflow flag check

```
  18 int_sbb R77 <- R54 R57
  19 store_membase_reg [arm_fp + 0x24] <- R77
  20 cond_exc_c OverflowException
```
this wasn't properly handled by the arch lowering pass.

Fixes https://github.com/mono/mono/issues/13284
2019-03-21 08:15:31 -04:00
Nikita Voronchev 037faa47cc [WinForms] Related Forms closing issue (#13150) (#13151)
Fixes #13150
2019-03-21 12:57:55 +01:00
lateralusX b554e0ea2c Increase spin-count on test to not end up in frequent sleeps on multicore machines. 2019-03-21 11:43:55 +01:00
lateralusX 33ea64cf7e Add UTC timezone in WinRT GetSystemTimeZones fallback implementation.
Needed by tests when hitting fallback solution in TimeZoneInfo.WinRT.cs.

Fix also sort the TimeZones similar to how its done in .NET Framework/Core.
2019-03-21 11:38:29 +01:00
Zoltan Varga 6a0a5bf3ca [netcore] Implement/fix enum/nullable comparers. 2019-03-21 11:33:34 +01:00
Zoltan Varga a6dc1cec3b [netcore] Implement RuntimeAssembly.GetSatelliteAssembly (). 2019-03-21 11:33:34 +01:00
Zoltan Varga 622bb8d5d5 [jit] Add JitHelpers.EnumEquals ()/EnumCompareTo () intrinsics. 2019-03-21 11:33:34 +01:00
Egor Bogatov 36a62bbf8a [netcore] Implement missing bits in ThreadPool (#13566)
* implement missing bits in ThreadPool

* remove [SecurityCritical]
2019-03-21 11:29:43 +01:00
Kenneth Pouncey 7dbcf1ed4b Add more tests for websockets. 2019-03-21 11:02:43 +01:00
Kenneth Pouncey a15526af3a [wasm][websockets]Fix Error Code not reported correctly with ClientWebSocket 2019-03-21 11:01:24 +01:00
Jan Kotas f2065c849a Hoist calls to IsBitwiseEquatable (dotnet/coreclr#23381)
Smaller IL is easier for JIT

Signed-off-by: dotnet-bot <[email protected]>
2019-03-21 08:10:47 +01:00
Marek Safar 701ca04b36 Update with shared partition changes 2019-03-21 08:05:14 +01:00
Jan Kotas 48114c0375 Unify EnumInfo and NamesAndValues
Signed-off-by: dotnet-bot <[email protected]>
2019-03-21 08:05:14 +01:00
Alexander Kyte 42c3b73ac1 [merp] Fix anon allocation, use MAP_PRIVATE 2019-03-21 07:48:25 +01:00
Egor Bogatov 8cf878ff50 advanced MemberData support 2019-03-21 07:46:56 +01:00
Bernhard Urban 4111910dd8 [llvm] dump bitcode file even if verifier fails (#13556)
[llvm] dump bitcode file even if verifier fails

This can be useful for debugging issues in the products.
2019-03-20 19:45:39 -04:00
Johan Lorensson d3a2841e93 Adjust genconst to changes in winsetup.bat. (#13554)
When logic moved from winsetup.bat into an msbuild task that changed the
console output of winsetup.bat causing problems for genconst to find
MONO_VERSION and MONO_CORLIB_VERSION. There was also a potential problem
where winsetup.bat couldn't find msbuild.exe if not included in PATH.

This fix makes sure winsetup.bat detect and setup a full msbuild environment
before running msbuild.exe. It also change genconsts to look at the generated
config.h for the correct values of MONO_VERSION and MONO_CORLIB_VERSION that
will be used by the runtime builds.
2019-03-20 18:48:20 -04:00
Bernhard Urban 00d871d103 [ssa] avoid code motion to try-blocks (#13555)
[ssa] avoid code motion to try-blocks

Consider
```
BB4:  // successor BB5, BB9
[...]
br [B9]

BB5: // catch handler block for BB4
[...]
br BB9

BB9:
aotconst R90
gc_safe_point R90
[...]
```

Previously, our invariant code motion pass would move `aotconst R90` to the end of BB4. Unfortunately, BB4 contains instructions that can cause an exception and thus control flow is broken and continues to BB5. `aotconst R90` wouldn't be loaded correctly in this scenario.

When lowered to LLVM IR this is more obvious, and the verification pass of LLVM catches this.

Fixes https://github.com/mono/mono/issues/13460
2019-03-20 18:45:47 -04:00
Thays Grazia 4e13c53451 [dim] System.MethodAccessException is thrown for a protected method declared in an interface (#13513)
* ```
interface I1<T>
{
    sealed protected void M1()
    {
        System.Console.WriteLine("M1");
    }
}

interface I3<T> : I1<T>
{}

interface I2<T> : I3<T>
{
    static void Test(I2<int> x)
    {
        x.M1();
    }
}

class A : I2<int>
{
    static void Main()
    {
        I2<byte>.Test(new A());
    }
}
```
When a interface implements another interface and they are generics, we don't need to check the datatypes of generics, we only need to check the inheritance.
Fixes 13467

* Adding test.

* Using the getter functions

* Initializing klass->interfaces/interfaces_count.

* Update mono/metadata/class.c

Co-Authored-By: thaystg <[email protected]>

* Fixing side effect on dim-simple.il
2019-03-20 18:08:51 -04:00
Aleksey Kliger (λgeek) 60221d88d5 [aot] Fix a few memory leaks (#13514)
1. aot-compiler: don't leak `MonoCustomAttrInfo`

2. aot-runtime: don't leak sigs when decoding wrapper references.  All of these cases we decode a sig (which uses malloc), and then call some method that immediately calls `mini_get_underlying_signature` which dups the sig, so the one from the decode isn't needed anymore.
2019-03-20 16:50:25 +01:00
Alexander Köplinger 242596b243 Bump corefx 2019-03-20 12:10:31 +01:00
Johan Lorensson a0e999549e Merge pull request #13529 from lateralusX/lateralusX/fix-mixup-global-cotask-alloc
Fix mixup of Global Free and CoTaskMem Alloc in Marshal's Secure String implementation.
2019-03-20 05:44:35 -04:00
Egor Bogatov b87bd4f6e4 [netcore] Allow all primitive types to be passed to Buffer.BlockCopy (#13544)
* Update Buffer.cs

* allow all primitive types to be passed to BlockCopy

* convert Len to bytes
2019-03-20 08:41:58 +01:00
Egor Bogatov 8b4eef9387 [netcore] Initial MemberDataAttribute support (#13543)
This PR adds ~2200 tests to System.Runtime.Tests and ~1000 to System.Collections.Tests
2019-03-20 08:40:46 +01:00
Thays Grazia b811e645a3 When it is a sealed method in Interface it's not Static nor Virtual and shouldn't add virtual.
Fixes #13508
2019-03-20 08:36:21 +01:00
Alexander Köplinger 8aaf420efe Fix Windows MSI build 2019-03-20 01:49:26 +01:00
Thays Grazia 86e7400525 [metadata][dim] Unexpected System.NotSupportedException in presence of default interface implementations (#13468)
* namespace Application
{
	public interface I1 { void M1() { System.Console.WriteLine("Unexpected!!!"); }}

	public interface I2 : I1 { void I1.M1() { System.Console.WriteLine("I2.I1.M1"); }}

	public interface I3 : I1 { void I1.M1() { System.Console.WriteLine("I3.I1.M1"); }}

	public interface I4 : I1 { void I1.M1() { System.Console.WriteLine("I4.I1.M1"); }}

	class Test10 : I1, I2, I3, I4 { public void M1() { System.Console.WriteLine("Test10.M1"); } }

	class MainClass {
		public static void Main(string[] args)
		{
			I1 var = new Test10();
			var.M1();
		}
	}
}

The interface method M1 is overridden at I1, at I2, at I3, at I4. The class Test10 overrides method M1 so regardless of having methods overriden in interface, the method of the class should be priority in this case. And then I remove the conflicts because there is not a conflict anymore.
2019-03-19 19:26:09 -03:00
Egor Bogatov 3a2d027e5e fix literals 2019-03-19 23:13:58 +01:00
Sung Yoon Whang dd6a9063c9 Remove timer in RuntimeEventSource (dotnet/coreclr#23311)
* Change RuntimeEventSource's counter types

* cleanup

* cleanup

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 23:02:11 +01:00
Grant 0584d63bf1 Trim/TrimStart/TrimEnd methods for Memory and Span (dotnet/coreclr#22798)
* Span.Trim

* Add another helper

* Remove redundant comments

* Optimize Trim(ReadOnlySpan<char>)

* Suggested overload for byte

* CR fixes

* CR fix

* Add Span overloads

* Add Memory overloads

* CR

* Rename method

* Optimization

* Tweaks

* Refactor

* Opt

* Use 2 helpers

* CR fixes

* CR fixes

* Nits

* CR fixes

* remove in params

* Bug

* Bug

* Move Trim methods to their own dedicated file

* Add char overloads

* Use Contains

* CR fixes

* Optmize ClampNull

* Nit

* Revert optimization

* Make existing implementations consistent with new

* Revert existing methods

* Move helpers

* Span, Memory and RoM should use consistent pattern

* POC for changing RoS

* Revert POC

* Use consistent idiom

* More inlining of explaining vars

* Use expression body for existing code

* CR fixes

* Nit

* Grammar

* CR fixes

* Fix perf bug in existing code

* Perf fix

* Force CI build

* Force CI

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 22:29:01 +01:00
Egor Bogatov 2785cdbd30 fix typo 2019-03-19 22:27:50 +01:00
Alexander Köplinger a0f593958b [ci] Fix wrong redirect which would overwrite Make.config 2019-03-19 21:53:40 +01:00
Alexander Köplinger dbc3c1a1cd [sdks] Build mac in Mono SDKs (#13535)
Enables building of the xammac runtime and BCL/tests into the SDKs archive.

Contributes to #11397
2019-03-19 20:44:42 +01:00
Bernhard Urban 4cd5068230 [aot] force v7 on arm when using LLVM on iOS (#13521)
[aot] force v7 on arm when using LLVM on iOS

In https://github.com/mono/mono/pull/11172 we added passing `-march=arm` to `llc`, so that newer LLVM would generate code correctly for the target arch. Unfortunately this seems to break older LLVM, that is still used for 32bit code on Xamarin.iOS. For iOS we need to force it to armv7, otherwise it will try to substitute certain locking primitives with builtins that aren't available as hardware instructions on armv5.


Before this change:

```console
$ nm ./obj/iPhone/Release/mtouch-cache/armv7/mscorlib.dll-llvm.o | grep sync_
         U ___sync_fetch_and_add_4
         U ___sync_lock_test_and_set_4
         U ___sync_synchronize
         U ___sync_val_compare_and_swap_4
00079e1c T _mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext
00057f80 T _mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken
00058430 T _mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken
         U _p_1214_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken_llvm
         U _p_1217_plt_mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken_llvm
         U _p_1735_plt_mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext_llvm
         U _p_1976_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_llvm
         U _p_37_plt_mscorlib__jit_icall_ves_icall_thread_finish_async_abort_llvm

```

After this change:

```console
$ nm ./obj/iPhone/Release/mtouch-cache/armv7/mscorlib.dll-llvm.o | grep sync_
0007008c T _mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext
00050654 T _mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken
00050ab4 T _mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken
         U _p_1214_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_int_System_Threading_CancellationToken_llvm
         U _p_1217_plt_mscorlib_System_Threading_SemaphoreSlim_WaitUntilCountOrTimeoutAsync_System_Threading_SemaphoreSlim_TaskNode_int_System_Threading_CancellationToken_llvm
         U _p_1735_plt_mscorlib_System_Runtime_CompilerServices_AsyncMethodBuilderCore_ThrowAsync_System_Exception_System_Threading_SynchronizationContext_llvm
         U _p_1976_plt_mscorlib_System_Threading_SemaphoreSlim_WaitAsync_llvm
         U _p_37_plt_mscorlib__jit_icall_ves_icall_thread_finish_async_abort_llvm
```

Fixes https://github.com/mono/mono/issues/13478
2019-03-19 12:46:00 -04:00
Alexander Kyte 04d65f2986 [runtime] Default llvm to self-init+direct native calls (#13312)
* [runtime] Default llvm to self-init

Now the init code is behind llvm_plt_init. Setting
--aot=llvm-plt will bring back the legacy llvm+plt behavior

* [llvm] Mark managed methods no-inline by llvm

* [runtime] Clean up self-disabling machinery

* [llvm] Skip self-init on cctors

* [runtime] Always make ctors call their cctors

* [runtime] Improve mono_print_unwind_info, add cases

* [runtime] Fix too-early eager calling of cctors

We emitted all of the lazy checks and init around a specific static
method, but still were initializing it when we initialized methods
that access it. This made static cctors run before they were supposed
to.

The problem was that the call site here has method == NULL, because
we don't compute it. That's expected, as we don't compute the method
along this path.

This initial "&&" looks like it was supposed to avoid calling the method
on a null MonoMethod reference. This preserves that, while fixing the
control flow issues.

* [runtime] Associate init_method native code with MonoMethod

* [runtime] Future-proof against aot init wrapper subtype mixups

* [runtime] Fix goto in AOT-init change for c++

* [runtime] Move docs for llvm-disable-self-init into runtime

* [runtime] Fix bitcode, remove unneeded wrapper around init icall

* [llvm] Include global prefix in init name

* [comment] Describe debugging usage of llvm self-init disable flag

* [aot] Consolidate mangler string append lines

* [llvm] Make self-init documentation changes

* [llvm] Rename self-init funcs, mini_llvmonly_ to mini_llvm_

* [runtime] Enable inlining for methods without init
2019-03-19 11:13:11 -04:00
lateralusX d4e5d14569 Fix mixup of global and cotask mem alloc heaps in Marshal's Secure String. 2019-03-19 15:53:23 +01:00
Bernhard Urban 6cb5c7f9cf [llvm] fix field init for platforms where unbox_trampolines tables are not used (#13527)
Fixes https://github.com/mono/mono/issues/13522
2019-03-19 15:31:44 +01:00
Kenneth Pouncey d4dec33b84 Merge branch 'master' of https://github.com/mono/mono into wasm-websocket-tests 2019-03-19 14:38:15 +01:00
Zoltan Varga 7a5487b966 [netcore] Ongoing work. (#13509)
* [netcore] Avoid casting to generic parameters in gen-xunit-runner.

* [netcore] Make the build-/run- targets more generic, add support for more test suites.

* remove NIE from Exception

* [netcore] Convert gen-xunit-runner to use roslyn for code generation instead of codedom.

* [netcore] Add check target to run all test suites.
2019-03-19 12:19:33 +01:00
Vsevolod Kukol 8a292ff635 Bump bockbuild to fix Gtk NSView embedding on Mac (#13511)
This fixes mouse event handling for NSViews embedded in Gtk.

Fixes VSTS #802376
Fixes VSTS #821841
2019-03-19 10:23:59 +01:00
Alexander Köplinger 31516f0b3e Reduce number of classes in winaot mscorlib. (#13341)
* Reduce number of classes in winaot mscorlib.

Winaot profile should be a Windows AOT friendly profile close to mobile
and consoles. At some point it was set to include the full net_4_x that
cause problems on none desktop platforms. This fix reduce the set to only
include classes similar to mobile and console profiles.

* Reverting changes to TimeZoneInfo test when reducing classes in corlib winaot.

* Move SafePasswordHandle to win32_build_corlib profile.

* Excluded some additional none Windows sources from win32_build/winaot profile.
2019-03-19 10:07:13 +01:00
monojenkins cecd6b316f [csproj] Update project files 2019-03-19 09:06:36 +00:00
Levi Broderick 909cae3de9 Add Utf8String skeleton (dotnet/coreclr#23209)
Utf8String is an experimental type that is string-like (heap-allocated, immutable, variable-length, null-terminated) but whose inner representation is UTF-8, not UTF-16.

This is a skeleton implementation of the basic API shape. The ecosystem of APIs has not yet been built around it. All Utf8String-related code is currently surrounded by ifdefs to allow easy identification and removal from release branches.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 09:44:07 +01:00
Vincent Povirk d21d4764e8 [mono/tests] Fix out of tree build. 2019-03-19 09:40:06 +01:00
Levi Broderick e9e902b929 Add Rune.TryEncodeToUtf8 and related APIs (dotnet/coreclr#23250)
Also renames the existing Encode / Decode APIs per design review feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-03-19 09:33:25 +01:00
Thays Grazia 4fbdcf504d [dim] Interface with sealed method (#13501)
* '''
interface I1
{
   sealed void M1()
   {
       System.Console.WriteLine(“M1”);
   }
}

interface I2 : I1
{
   static void Test<T>(T x) where T : I2
   {
       x.M1();
   }
}

class A : I2
{
   static void Main()
   {
       I2.Test(new A());
   }
}
'''

When an interface implements a Sealed method, this method is not virtual, so it will not be available at vtable. But in the IL the call is a virtual call, but in this case we don't need to search at vtable.

Fixes #13466

* Change IL test.
2019-03-18 18:46:07 -03:00
Johan Lorensson a66f944ff7 Fix a couple of build warnings under MSVC. (#13475) 2019-03-18 14:38:27 -04:00
Alexander Köplinger 9bcad32ca5 Update csproj 2019-03-18 19:30:42 +01:00
Marek Safar b1a155979b Update codeowners (#13505) 2019-03-18 17:32:43 +01:00
Ludovic Henry 1965786397 Update CODEOWNERS 2019-03-18 08:50:19 -07:00
Alexander Kyte f7796b0da0 Merge pull request #13447 from alexanderkyte/fallback_merp_allocator
[crash] Fallback to MAP_ANONYMOUS for allocator
2019-03-18 11:49:52 -04:00
Zoltan Varga d5dfc5e76c [jit] Add RuntimeHelpers:IsBitwiseEquatable () intrinsic. (#13499)
* [jit] Add RuntimeHelpers:IsBitwiseEquatable () intrinsic.

* Update access modifier
2019-03-18 16:33:29 +01:00
Zoltan Varga 5232408f7a [runtime] Avoid putting non-virtual and non-static DIM methods into vtables, roslyn generates these for private property accessors. (#13449)
Fixes part of https://github.com/mono/mono/issues/13374.
2019-03-18 11:54:33 -03:00
Alexander Köplinger 12043bb6f5 [System.Drawing.Common] Enable debug symbols
The facade contains code now so we should build a .pdb.
2019-03-18 15:43:30 +01:00
Zoltan Varga 32b84339cb [netcore] Disable runtime cleanup on netcore, coreclr does not cleanup either. Also disable aborting background threads, its no longer needed. (#13469) 2019-03-18 10:40:22 -04:00
Jay Krell 23999ca43d Cleanup mono_array_new_1, mono_array_new_2, mono_array_new_3, mono_array_new_4.
Mainly to remove the dynamic alloca but also combine common code.
If there is a perf concern then we can forceinline mono_array_new_n.
2019-03-18 15:02:30 +01:00
Alexander Köplinger 5521ad349f [System.Net.Http] Port https://github.com/xamarin/xamarin-macios/pull/5769 to mono 2019-03-18 14:39:54 +01:00
Alexander Köplinger e0326df7c6 More Windows MSI fixes 2019-03-18 13:19:17 +01:00
Alexander Köplinger d431fd5619 Fix nunit-lite signing key 2019-03-18 12:40:38 +01:00
Alexander Köplinger 0ae04b8e80 Fix Windows MSI build, msbuild is now in Current instead of 15.0 2019-03-18 11:40:03 +01:00
Alexander Köplinger 362eface2c Remove more unnecessary nunit24 cruft 2019-03-18 11:31:06 +01:00
Johan Lorensson 273776c737 Merge pull request #13482 from lateralusX/lateralusX/windows-build-script-updates
Windows full AOT build scripts update.
2019-03-18 06:15:42 -04:00
Egor Bogatov 9f25f0f540 cache downloaded net core sdk 2019-03-18 11:15:09 +01:00
Marek Safar 4014060cca Reflect shared code changes 2019-03-18 11:12:40 +01:00
Levi Broderick 9ef79a5156 Make more types eligible for vectorized code paths in MemoryExtensions (#20855)
Types like sbyte, ushort, and other 8-bit / 16-bit elemental types are now directed down the fast vectorized code paths that previously only byte and char were eligible for.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-18 11:12:40 +01:00
monojenkins e52716f9a0 [bcl] Update BCL Linked Size 2019-03-18 11:08:16 +01:00
EgorBo 88acef1575 fix formatting 2019-03-18 10:49:06 +01:00
Egor Bogatov 253753bdb7 Add failing tests 2019-03-18 10:49:06 +01:00
Egor Bogatov 0801bfe4aa fix bug 2019-03-18 10:49:06 +01:00
Egor Bogatov 0d48237457 fix case when InlineData's type != ParameterType 2019-03-18 10:49:06 +01:00
Zoltan Varga 8b9d89b150 [netcore] Fix running tests. (#13493)
* [netcore] Fix running the tests.

* [netcore] Implement missing enum icalls.
2019-03-17 20:55:49 -04:00
Marek Safar fc7ab5076e Adapt shared Enum 2019-03-17 13:42:00 +01:00
Egor Bogatov 5df1bae25d Move Enum and CorElementType to shared (dotnet/coreclr#23177)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-17 13:42:00 +01:00
Sung Yoon Whang bc420a440e Fixing some payload serialization issue on new EventCounters (#23295)
* Fixing some payload serialization issue on new EventCounters

* Fix build error

Signed-off-by: dotnet-bot <[email protected]>
2019-03-17 08:09:21 +01:00
Nikita Potapenko cfa37ea29b Fix typo (dotnet/coreclr#23300)
.Net -> .NET

Signed-off-by: dotnet-bot <[email protected]>
2019-03-16 18:44:58 +01:00
sancheolz 1ca9fcc201 Fix local variable assign
Local variable must be assigned before use
2019-03-16 10:30:49 +01:00
[email protected] f278deee46 Fix Stackoverflow when SplitContainer`s SplitterDistance setted in SplitterMoved event subscription 2019-03-16 10:30:49 +01:00
monojenkins 9522ae42bb [bcl] Update BCL Linked Size 2019-03-16 10:22:50 +01:00
Zoltan Varga a0d0209fb1 [netcore] Add support for running tests.
* Move the sdk download from netcore/sample/Makefile to netcore/Makefile
* Add targets for running the System.Runtime.Tests test suite.
2019-03-16 10:20:51 +01:00
Jay Krell d34b6da0d8 [Coop] Convert ves_icall_System_Globalization_CultureData_fill_number_data. (#13477)
* [Coop] Convert ves_icall_System_Globalization_CultureData_fill_number_data.

Tested by running this program:
```
class A
{
	public static void Main()
	{
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.CompareInfo);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.DateTimeFormat.AMDesignator);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.DateTimeFormat.DateSeparator);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.DisplayName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.EnglishName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.IsNeutralCulture);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.IsReadOnly);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.LCID);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.Name);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NativeName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NumberFormat.CurrencySymbol);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NumberFormat.NumberDecimalDigits);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.NumberFormat.NumberDecimalSeparator);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.Parent);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.TextInfo);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.ThreeLetterISOLanguageName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.ThreeLetterWindowsLanguageName);
		System.Console.WriteLine(System.Globalization.CultureInfo.CurrentUICulture.TwoLetterISOLanguageName);
	}
}
```

which covers some but not all of the data.

*  - Use gint32 instead of int when interfacing directly with managed code.
   Indirectly would be passing the parameter off to additional native code; compiler
   can often silently convert.
   int will always be 32 bits.

 - Expand tedious error-prone code instead of using preprocessor to automate.

 - Add comments that the native and managed types must match.

 - Rename the managed type to match the native type (not necessary,
   but might as well have them grep perfectly coincidentally.).

 - Sort the fields and some of their uses for easier reading.
 It might be infinitesimally faster to line up the order
 with the native structure, to synchronize access order (i.e. sequential access to all).

 - Restore parameter name to number_index.

 - Validate, with assert, number_index maximum not just minimum.

* Restore the group_sizes logic.
group_sizes is an array of up to two integers, -1 terminated.

* restore const

* Add comment explaining the ordered -- sorted alphabetically.
2019-03-15 16:56:41 -04:00
Larry Ewing e61f00cd2d Merge pull request #12984 from kjpou1/wasm-typed-arrays
[wasm] Typed Array support for better memory usage
2019-03-15 15:36:17 -05:00
Jo Shields 0f457095e5 Don't produce nunit-console scripts in bin/ (#13480)
NUnit bundle is gone, these scripts are empty and useless

```
10:27:45  DEBUG: Checking for unpackaged file(s): /usr/lib/rpm/check-files /builddir/build/BUILDROOT/mono-core-6.1.0.462-0.nightly.1.epel6.x86_64
10:27:45  DEBUG: BUILDSTDERR: error: Installed (but unpackaged) file(s) found:
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console2
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console4
10:27:45  DEBUG: RPM build errors:
10:27:45  DEBUG: BUILDSTDERR:     Installed (but unpackaged) file(s) found:
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console2
10:27:45  DEBUG: BUILDSTDERR:    /usr/bin/nunit-console4
```
2019-03-15 19:16:15 +01:00
Johan Lorensson 36a2cabc7b Default to sgen on Windows x64. (#13473)
Since Boehm is not supported on Windows x64 we should set sgen as default
GC instead of forcing the use of --disable-bohem.
2019-03-15 12:12:10 -04:00
lateralusX 47ee8c8f46 Excluded some additional none Windows sources from win32_build/winaot profile. 2019-03-15 17:02:48 +01:00
Zoltan Varga db12fc8666 [wasm] Update to emscripten 1.38.29. 2019-03-15 10:33:37 -05:00
Justin Van Patten 202a217e15 Collection<T>: Validate parameters in the public methods (#23166)
I was looking over the new Range methods on `Collection<T>` and it occurred to me that for all existing methods, parameter validation is done in the *public* methods before calling the *protected virtual* methods. This changes the new Range methods to do the same.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-15 16:01:50 +01:00
lateralusX dab3cc35c0 Windows full AOT build scripts update.
* Only do clean/rebuild when an assembly changed.
* Add wrappers for different full AOT build configurations.
* Make scripts callable from different working directory.
2019-03-15 15:58:50 +01:00
Alexander Köplinger cfb3704940 [eglib] Remap g_utf16_len and g_utf16_len to monoeg_ prefix (#13476)
They fail a xamarin-macios public symbols check otherwise (monoeg_ is whitelisted).
2019-03-15 15:56:05 +01:00
Johan Lorensson f375ffd08c Merge pull request #13472 from lateralusX/lateralusX/enable-all-ci-tests-llvm-windows
Enable all CI test suites for Windows x64 full AOT + LLVM.
2019-03-15 10:27:13 -04:00
Zoltan Varga 9cdb5b4a12 [llvm] Fix receiving rgctx argument in DIM methods, they receive the mrgctx even if they are not generic. 2019-03-15 14:34:24 +01:00
Jo Shields 85ccf3ec02 Merge pull request #13437 from DavidKarlas/patch-1
Fix generating `.dSYM` for GTK assemblies
2019-03-15 09:15:15 -04:00
Bernhard Urban 4a2e7ce6f9 [mini] Remove public symbol helper_sig_llvmonly_imt_trampoline (#13462)
Fixes Xamarin.Tests.Misc.PublicSymbols test.
2019-03-15 12:34:43 +01:00
Marek Safar 2fa8290b7a Update for shared partition change 2019-03-15 11:20:43 +01:00
Egor Bogatov 6b2958e199 Move TypeLoadException to shared (dotnet/coreclr#23238)
* fix coding-style

* shorter form for TypeName property

* move coreclr-specific ctor to TypeLoadException

Signed-off-by: dotnet-bot <[email protected]>
2019-03-15 11:20:43 +01:00
Kenneth Pouncey b9bc111f01 Address review comments - Rename HostObjectInterface to IHostObject 2019-03-15 10:52:21 +01:00
Larry Ewingandkjpou1 e00dc00649 Update sdks/wasm/binding_support.js
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:34:16 +01:00
Larry Ewingandkjpou1 953acc3afd Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:32:57 +01:00
Larry Ewingandkjpou1 dd92015bbd Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:32:32 +01:00
Larry Ewingandkjpou1 caedcc8270 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:32:15 +01:00
Larry Ewingandkjpou1 e346211299 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:31:58 +01:00
Larry Ewingandkjpou1 e3a1b8714e Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:31:36 +01:00
Larry Ewingandkjpou1 b325eaacd1 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:31:10 +01:00
Larry Ewingandkjpou1 892b7ac039 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/ArrayBuffer.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:30:52 +01:00
Larry Ewingandkjpou1 4d17766a23 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:54 +01:00
Larry Ewingandkjpou1 e3ed42a492 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:37 +01:00
Larry Ewingandkjpou1 670b032653 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:22 +01:00
Larry Ewingandkjpou1 a4bb7611b8 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:29:11 +01:00
Larry Ewingandkjpou1 57aa52db5a Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:28:23 +01:00
Larry Ewingandkjpou1 6ff0679677 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/Array.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:28:06 +01:00
Larry Ewingandkjpou1 3e4706cf24 Update sdks/wasm/framework/src/WebAssembly.Bindings/Core/ArrayBuffer.cs
Co-Authored-By: kjpou1 <[email protected]>
2019-03-15 10:27:51 +01:00
Kenneth Pouncey 7708f047d6 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-03-15 09:35:47 +01:00
Marek Safar 0bd836b2f2 [System.Private.CoreLib] Remove unused variables from TypeNameParser 2019-03-15 09:28:07 +01:00
Marek Safar 25abfa4a3f [System.Private.CoreLib] Small StackTrace cleanup 2019-03-15 09:27:41 +01:00
lateralusX d06927eecf Move SafePasswordHandle to win32_build_corlib profile. 2019-03-15 09:20:03 +01:00
lateralusX 8a77ff6c05 Reverting changes to TimeZoneInfo test when reducing classes in corlib winaot. 2019-03-15 09:20:03 +01:00
lateralusX e36be73ffb Reduce number of classes in winaot mscorlib.
Winaot profile should be a Windows AOT friendly profile close to mobile
and consoles. At some point it was set to include the full net_4_x that
cause problems on none desktop platforms. This fix reduce the set to only
include classes similar to mobile and console profiles.
2019-03-15 09:20:03 +01:00
lateralusX 3fabfccb73 Enable all CI test suites for Windows x64 full AOT + LLVM. 2019-03-15 08:50:43 +01:00
Egor Bogatov e8a66f38da bump netcore sdk version 2019-03-14 23:39:05 +01:00
lateralusX 8a6a8b7f88 Fix missing llc options for Windows x64 full AOT + LLVM mini regression tests. 2019-03-14 16:39:36 -04:00
Vlad Brezae 73ff4a7434 [interp] Make sure we call init before registering counters (#13457)
[interp] Make sure we call init before registering counters
2019-03-14 15:55:56 -04:00
Jo Shields cd8dc77a8e [win] Don't try to install NUnit 2.4, it's dead now 2019-03-14 15:01:34 -04:00
Alexander Kyte b20b86ff11 Merge pull request #13247 from lateralusX/lateralusX/fix-llvm-dwarf-cfi-windows-x64
Fix LLVM Dwarf CFI on Windows x64. Bump to corresponding LLVM commit.
2019-03-14 13:30:48 -04:00
Kenneth Pouncey 9f2dd3f554 [wasm][doc] Add Packager doc (#13411)
* Add Packager doc

* Fix numbering

* Address review comments

Packager.exe to packager.exe

* Move packager readme doc from getting started as per review comment.

* - Addresses review comment -- Fix emdash in `packager.exe -help` command line.

* Fix command line argument -- instead of single -
2019-03-14 17:45:56 +01:00
Vlad Brezae 620a46d8f2 [profiler] Fix vtune build (#13390)
[profiler] Fix vtune build
2019-03-14 11:19:47 -04:00
Marek Safar c194209317 [netcore] Generate full project setup in gen-xunit-runner 2019-03-14 14:35:29 +01:00
Jb Evain 959fbda60a [sdb] Add property AssemblyMirror.HasDebugInfo (#13353)
* [sdb] Add property AssemblyMirror.HasDebugInfo

* Fix mono_debug_image_has_debug_info to work with ppdb

* Bump API snapshot submodule
2019-03-14 09:44:17 +01:00
Aleksey Kliger (λgeek) c0b48793db Custom modifier equivalence, duplication, appending and inflation (#13320)
This all stems from ECMA 335, 7.1.1:

> The CLI itself shall treat required and optional modifiers in the same
> manner. Two signatures that differ only by the addition of a custom
> modifier (required or optional) shall not be considered to match. Custom
> modifiers have no other effect on the operation of the VES.

This rule means that when comparing signatures, we have to treat two types that
differ only in their custom modifiers as distinct. In particular, we have to do
this when comparing signatures in order to fill in the vtable for a class.  And
moreover, we have to concatenate custom modifiers when doing generic
instantiation.  If a method in a generic type has signature `T modopt(IsConst)
Method()` and we instantiate T with `int32 modopt(IsLong)`, we are expected to
produce the signature `int32 modopt(IsConst) modopt(IsLong) Method()` (with the
custom modifiers on `int32` in that order).

So this PR implements the following operations:
1. custom modifier appending during `mono_metadata_type_dup_with_cmods`
2. custom modifier-respecting comparison in `do_mono_metadata_type_equal`

To do this, we actually have to introduce a second representation of custom
modifiers: in the normal representation, all the cmod type specs come from a
single image.  Whereas now, due to inflation of signatures, we can have a mix
of modifiers from different images.  So in the MonoAggregateModContainer
representation, we pair each typespec token with the image in which it is to be
resolved.

We keep the old representation (a single image to resolve the entire set of
typespec tokens) because it's natural when you're just reading from a single
image.  Also this representation is part of the embedding API.

---

### But that's not all ###


It is possible for generic parameters of a generic class to appear in the
_custom modifiers_ of a type in a method signature.  For example:
```
    T modopt(Nullable`1<T>) Method ()
```

In this case, when we inflate this signature, we need to inflate not only the
return type, but also the modifiers on a return type.

That means our old aggregate representation (where each modifier is a pair of a
MonoImage and a typespec token) is inadequate: we can inflate a signature and
get a custom modifier that doesn't appear as a typespec in any table of any
existing image.

This is the same situation as generic instances: as a program runs, it creates
generic instances that are not part of the source code.  So we solve it the
same way as with generic instances.

Our new `MonoAggregateModContainer` representation is a pointer into memory owned
by a MonoImageSet that contains an entire MonoType for each custom modifier.

The invariant is that the aggregate modifier container is allocated from a
mempool of a `MonoImageSet` that includes the images of all the modifiers.

In general, when inflating, we first create a provisional candidate
MonoAggregateModContainer on the stack and then look it up the image set that
should own it and then look for a "canonical" mod container in the
`MonoImageSet:aggergate_modifiers_cache`

---

Also had to bump the AOT image format, which now always reads back in using the aggregate representation.

---

This should address #10564, #10565, #12422, #10945 (again), #6936, and the parts of #11350 that **don't** deal with arrays.

---

TODO:

- [x] Add some representative test cases to this PR.
- [ ] Modify our acceptance tests to run the various disabled Roslyn tests.
2019-03-14 09:16:42 +01:00
Johan Lorensson 557d8406f6 Merge pull request #13444 from lateralusX/lateralusX/fix-simd-llvm-issue
Fix error in SIMD test on Windows x64 LLVM due to changed llc defaults.
2019-03-14 03:43:12 -04:00
Maxim Lipnin 55fbd14763 Remove nunit24 from mono build and tree (#13415)
* Remove nunit24 from mono build and tree

* More cleanup

* Fix build

* [csproj] Update project files
2019-03-13 23:47:39 +01:00
Levi Broderick f62dfab807 Add OperationStatus-based UTF8 transcoding APIs (dotnet/coreclr#23219)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-13 23:46:08 +01:00
Alexander Kyte 1a574284ac [crash] Fallback to MAP_ANONYMOUS for allocator
This is helpful by allowing the crash reporter to work even while
unable to write to the working directory.
2019-03-13 14:30:57 -04:00
Zoltan Varga 8fed6666b0 Address review comments. 2019-03-13 17:52:11 +01:00
Zoltan Varga dfb3ebd706 [netcore] Improvements to gen-xunit-runner.
* Add support for response files.
* Fix encoding of small primitive types.
* Print number of run/failed/skipped tests.
2019-03-13 17:52:11 +01:00
Zoltan Varga 23fea25e80 [netcore] Define COMPlus_DebugWriteToStdErr=1 in make run to enable debug logging. 2019-03-13 17:52:11 +01:00
Zoltan Varga c3d77000a7 [netcore] Test fixes.
* EqualityComparer.cs: Add LastIndexOf ().
* RuntimeAssembly.cs: Implement	       CreateAssemblyName ().
* AssemblyLoadContext.cs: Handle windows paths.		  Add DoAssemblyResolve () method.
* Array.cs: Add/fix error handling. Implement LastIndexOf ()/GetRawArrayData ().
* Attribute.cs:	    Implement.
* Buffer.cs: Add/fix error handling.
* DefaultBinder.cs: Implement.
* RuntimeType.cs: Implement HasSameMetadataDefinitionAs ().
* RuntimeEventInfo.cs: Ditto.
* RuntimeFieldInfo.cs: Ditto.
* RuntimeMethodInfo.cs: Ditto.
* RuntimePropertyInfo.cs: Ditto.
* MonoCustomAttrs.cs: Add eror handling. Implement inheritance support for parameters.
* gc.cs: Fix error handling.
* rttype.cs: Fix handling of null namespaces.
2019-03-13 17:52:11 +01:00
Zoltan Varga aa949e2114 [runtime] Add more error checking and special cases to the Array get/set icalls. 2019-03-13 17:52:11 +01:00
Zoltan Varga 46ae93a23c [runtime] Add a few more m_class accessors. 2019-03-13 17:52:11 +01:00
Zoltan Varga d5feee9c71 [runtime] Fix the ordering of the Buffer icalls. 2019-03-13 17:52:11 +01:00
Zoltan Varga 3dcee3319e [runtime] Avoid asserting if AppDomainUnloadedException is not found. 2019-03-13 17:52:11 +01:00
Zoltan Varga 7f9cb785f2 [runtime] Fix the creation of argument exceptions in netcore, the layout of ArgumentException is no longer visible to the runtime. 2019-03-13 17:52:11 +01:00
Zoltan Varga d7ba254448 [jit] Fix a IL verification error which the netcore tests run into. 2019-03-13 17:52:11 +01:00
Ankit Jain 4cb9a914f0 [msbuild] Update to track upstream vs16.0 branch (#13053) 2019-03-13 16:40:05 +01:00
Michal Strehovsky 90bdd5da71 Fix missed RelocatedType annotation
[tfs-changeset: 1735855]

Signed-off-by: dotnet-bot <[email protected]>
2019-03-13 15:58:58 +01:00
Aleksey Kliger d28aab8d56 [class-init] Take loader lock around mono_class_setup_interface_id_internal
Writing to MonoClass:interface_id must be done with the loader lock held.

Fixes assertion:
```
* Assertion at class-init.c:1830, condition `i == 0 || interfaces_full [i]->interface_id >= interfaces_full [i - 1]->interface_id' not met
```
2019-03-13 10:54:07 -04:00
lateralusX 9b440da1f2 Fix error in SIMD test on Windows x64 LLVM due to changed llc defaults. 2019-03-13 15:52:48 +01:00
Johan Lorensson eaa5805af7 Merge pull request #13393 from lateralusX/lateralusX/fix-build-warning-local-global
Fix build warning, local variable hides global.
2019-03-13 08:39:02 -04:00
Rolf Bjarne Kvinge a72e7ffc0d Revert "[mini] Inline Selector.GetHandle for tvOS and watchOS assemblies as well. (#13246)" (#13418)
Revert "[mini] Inline Selector.GetHandle for tvOS and watchOS assemblies as well. (#13246)"

This reverts commit c99fe4b462.

It doesn't work when LLVM is enabled for tvOS: https://github.com/xamarin/xamarin-macios/pull/5742#issuecomment-471007078, it causes multiple compilation errors like this:

    Process exited with code 1, command:
    /Applications/Xcode101.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang  -isysroot /Applications/Xcode101.app/Contents/Developer/Platforms/AppleTVOS.platform/Developer/SDKs/AppleTVOS12.1.sdk -Qunused-arguments -mtvos-version-min=12.1 -fembed-bitcode-marker -arch arm64 -c -o /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.o -x assembler /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.s
    /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.s:4665:14: error: invalid variant 'OBJC_SELECTOR_REFERENCES_.2@PAGE'
            adrp    x8, l_@OBJC_SELECTOR_REFERENCES_.2@PAGE
                           ^
    /private/var/folders/nh/n1y9qj2n40d7wpmx1mg9blg80000gn/T/mtouch.cache/arpl1vgs.js6/arm64/Xamarin.TVOS.dll-llvm.s:4673:18: error: invalid variant 'OBJC_SELECTOR_REFERENCES_.2@PAGEOFF'
            ldr     x1, [x8, l_@OBJC_SELECTOR_REFERENCES_.2@PAGEOFF]




<!--
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
-->
2019-03-13 08:05:48 -04:00
Alexis Christoforides f934b60854 [MacSDK] Bump Nuget to 4.8.2 2019-03-13 11:28:58 +01:00
Marek Safar fa7b007914 [System.Private.CoreLib] Remove duplicate checks 2019-03-13 10:35:25 +01:00
Sung Yoon Whang 6e85a0fb99 Add new counter APIs (dotnet/coreclr#23077)
* Refactor EventCounter and add PollingCounter

* Add PollingCounter

* Add IncrementingEventCounter and IncrementingPollingCounter

* Add MetaData API to Counters

* Some more refactoring

* removing commented out code

* some more cleanup

* build fix and addressing some PR comments

* Addressing PR feedback

* use StringBuilder to generate metadata string

Signed-off-by: dotnet-bot <[email protected]>
2019-03-13 10:03:41 +01:00
David Karlaš a716c9ad7b Fix generating .dSYM for GTK assemblies
Problem is that https://github.com/mono/bockbuild/blob/14535c270ea9f8d536efe6852700d8d1cb657c1f/packages/gtk%2B.py#L4 passes `gtk` for repository name to `GitHubPackage` which then uses this as package name. So when it's decided if `-g` should be added at https://github.com/mono/bockbuild/blob/5c2378112dc681cea0aa5c2447661fb13adbc46b/bockbuild/darwinprofile.py#L158-L159 it's false hence GTK assemblies don't get debug symbols.
2019-03-13 09:39:22 +01:00
Calvin Buckley 55d913c2d3 Bump corefx for System.Native posix_fadvise change (#13409) 2019-03-13 02:18:47 +01:00
Tanner Gooding cde76c1521 Fixing a couple of issues in the Utf8Parsing/Formatting code (#23134)
* Fixing NumberToSingle and NumberToDouble to handle DigitsCount == 0

* Fixing Utf8Formatter.Float to transcode non ASCII bytes

* Responding to PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-03-12 22:42:53 +01:00
Alexander Köplinger d884bd3e12 [corlib] Fix RuntimeFeatureTest.NoNewFeaturesAdded()
DefaultImplementationsOfInterfaces was enabled with https://github.com/mono/mono/pull/13417
2019-03-12 21:03:06 +01:00
Alexander Köplinger 92b435d6fe Move drawing types for XI/XM/wasm/orbis/unreal to System.Drawing.Common (#13414)
* Move drawing types for XI/XM/wasm/orbis/unreal to System.Drawing.Common

For XI/XM they were in Xamarin.iOS.dll/OpenTK-1.0.dll before.

For wasm/orbis/unreal we remove System.Drawing.dll from the profiles and
add the types to System.Drawing.Common.dll instead to align with the other
mobile profiles (only "net_4_x" and "build" still have System.Drawing.dll).

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-12 18:07:19 +01:00
Joshua Peterson 244c1aab8e Fix a possible crash while printing a warning (#13399)
The format string was incorrect in this case, which leads to a crash
in Unity. Simply remove the unused `%s` format specifier here.
2019-03-12 18:03:58 +01:00
monojenkins fb8554d76f [csproj] Update project files 2019-03-12 17:26:20 +01:00
monojenkins 0a85578bd0 Bump API snapshot submodule 2019-03-12 17:26:20 +01:00
Zoltan Varga 522a46dcac [corlib] Define FEATURE_DEFAULT_INTERFACES so RuntimeFeatures indicates DIMs are supported. 2019-03-12 17:26:20 +01:00
Kenneth Pouncey 205bb1666a [wasm][tests] Add WebSocket tests 2019-03-12 14:57:50 +01:00
Zoltan Varga 00c837d66a [netcore] Implement Type.GetType () overloads with assembly/type resolve delegates. (#13410)
Instead of extending the runtime gettype implementation, port the type parsing code
to C#.
2019-03-12 13:01:34 +01:00
Zoltan Varga ec7b9ec409 [jit] Implement Unsafe:ByteOffset<T> intrinsic. 2019-03-12 12:19:51 +01:00
Kenneth Pouncey 38ec3156f5 Address review by @Suchiman after conflict resolution. Thanks for the catch. 2019-03-12 11:02:28 +01:00
Kenneth Pouncey 9a73ea12b7 Confilct with Runtime.cs
Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays

# Conflicts:
#	sdks/wasm/framework/src/WebAssembly.Bindings/Runtime.cs
2019-03-12 10:11:04 +01:00
Larry Ewing 4ff1307e21 Remove all use of ContainsKey from js bindings (#13376) 2019-03-12 09:18:09 +01:00
Maxim Lipnin ad5fe197a3 Add reflected type to event methods (#13397)
Fixes https://github.com/mono/mono/issues/13350
Fixes https://github.com/mono/mono/issues/10277
2019-03-12 08:32:40 +01:00
Hugh Bellamy 030111234e Fix NRE in EqualStringArrays (dotnet/coreclr#23174)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-11 22:35:21 +01:00
Michal Strehovský 07c383b829 Replace Delegate.CreateDelegate (dotnet/corert#7147)
Replacing this with a pattern that is easier to statically analyze. We use the GetType/GetMethod/CreateDelegate pattern in several places already.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-11 22:20:53 +01:00
Alexander Köplinger b92a105992 [configure.ac] Fix configure checks for Mono.Native (#13395)
When the configure checks were ported from configure.cmake in corefx
a couple of mistakes happened:

- Using AC_TRY_COMPILE instead of AC_TRY_LINK:
  CMake's check_c_source_compiles() function compiles *and* links while
  AC_TRY_COMPILE only does the former. This hides potential linking issues
  which should fail the configure check.
- Using CFLAGS="-Werror -W....":
  This works in CMake but autoconf always appends the previously defined
  CFLAGS and since we set e.g. `-Wno-undefined` some configure checks
  would fail due to an unrelated warning being treated as an error.
  We need to only promot specific warnings to errors instead.

While looking at this I also found that we were setting CFLAGS after
we already AC_SUBST() it, we need to do this very close to the end of configure.ac.
Moved some code into that last block.

Finally, Android has special cases for sendfile and arc4random_buf where
they're defined in the header but aren't actually there for certain API profiles.
For now we disable arc4random_buf on Android and add a special check for sendfile.

* Fix sendfile with 6 parameters being misdetected

We need to make sure to actually prevent the implicit prototype since
in this case sendfile with different set of parameters actually exists
so the linker wouldn't fail.

Also fixed a few other cases of wrong configure checks due to missing headers.

* Move GSS checks into the Mono.Native checks section

This allows us to have a 1:1 mapping of the checks from configure.cmake
2019-03-11 20:36:40 +01:00
Thays Grazia 3537672955 [debugger] Fixing two crashes while debugging an Android app. (#13373)
* [debugger] Fixing two crashes while debugging an Android app.

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

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

#Fixes 12843
2019-03-11 15:55:47 -03:00
Alexander Köplinger 0d7ce1f767 Fix build on Alpine Linux (#13394)
- sys/sysctl.h isn't available on Alpine and not needed by the code,
  guard it using HAVE_SYS_SYSCTL_H like elsewhere. Added by https://github.com/mono/mono/pull/11855

- pthread_mutexattr_setprotocol doesn't support PTHREAD_PRIO_INHERIT,
  check return value. Added by https://github.com/mono/mono/pull/13333
2019-03-11 16:59:44 +01:00
Kenneth Pouncey cbe835d0c1 Use new HostObject instead of NewJSObject. 2019-03-11 15:36:33 +01:00
Kenneth Pouncey 911b21dff4 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays
# Conflicts:
#	sdks/wasm/framework/src/WebAssembly.Net.Http/WasmHttpMessageHandler.cs
2019-03-11 15:24:26 +01:00
Egor Bogatov d0013e438c Add System.Drawing converters to netstandard facade (#13326)
This PR adds missing System.Drawing converters thus it completes NS2.1 support (as of today) for all profiles except macOS\IOS specific ones: monotouch, tv, watch, xammac, xammac_net_4_5.
2019-03-11 13:23:31 +01:00
Zoltan Varga db67d18d0d [netcore] Ongoing work. (#13391)
* [runtime] Add a few new m_class inline functions.

* [netcore] Implement Array.IndexOf ().

* [netcore] Implement RuntimeHelpers.PrepareMethod ().

* Add error checks to RuntimeHelpers.GetUninitializedObject ().
* Fix some type attributes.
* Fix some TypedReference special cases.
2019-03-11 08:16:21 -04:00
Zoltan Varga 38a2639fc1 [netcore] Fix build. (#13392)
* [netcore] Fix build.

* Update Buffer.cs
2019-03-11 12:57:44 +01:00
lateralusX ce3bbb011b Fix build warning, local variable hides global.
On Windows MSVC build this cause:

warning C4459: declaration of 'mono_cfg_dir' hides global declaration
2019-03-11 12:36:25 +01:00
Johan Lorensson ed3039b377 Merge pull request #13367 from lateralusX/lateralusX/fix-windows-build-warning
Fix build warning in mono-error.h.
2019-03-11 07:12:29 -04:00
Kenneth Pouncey b124b51066 Address review comments.
- Cleanup docs.
- Cleanup implicit conversions.
- Remove ToSpan()
2019-03-11 12:02:11 +01:00
Zoltan Varga ea761357f8 [jit] Reenable the EqualityComparer:Default devirt optimization. (#13321) 2019-03-11 06:09:59 -04:00
Calvin Buckley e9e52de223 Fix System.Decimal regression from .NET Core on big endian (#13348)
Upstream must have rewritten, because the runtime checks were
replaced with the (not good for Mono) ifdefs.

Not throughly tested, but unbreaks build locally; waiting for CI
to come back with more results.

If it works, could someone get this upstream?
2019-03-11 10:20:49 +01:00
Johan Lorensson a91e3f162a Merge pull request #13366 from lateralusX/lateralusX/add-missing-public-header-to-dist
Include mono-forward.h public header on Windows.
2019-03-11 04:29:42 -04:00
monojenkins 0e804950b5 [csproj] Update project files 2019-03-11 09:11:16 +01:00
monojenkins 0086403d54 Bump API snapshot submodule 2019-03-11 09:11:16 +01:00
Steve Pfister a49d5df03f These changes help prep for refsrc System.Web
* DynamicRoleClaimProvider to help with legacy role management in web forms
* Added AppDomainManagerAssembly, AppDomainManagerType, and PartialTrustVisibleAssemblies
  properties to AppDomainSetup. They don't do anything, but having  them there
  helps lessen the amount of change in refsrc System.Web.
2019-03-11 09:11:16 +01:00
Larry Ewing b5082160c3 Remove linq usage from WasmHttpMessageHandler 2019-03-11 09:10:59 +01:00
Levi Broderick 31b5a4554a Refactor Encoding to split fast-path and fallback logic (#23098)
This refactoring is limited to ASCIIEncoding at the moment, but it can easily be applied to UTF-8 / UTF-16 / UTF-32.

High-level changes:
- Fallback logic has been split from the fast-path, improving performance of GetBytes and similar routines.
- All of the plumbing of when to invoke the fallback logic and how to manage leftover data has been moved into the base class.
- Almost all of the logic except for the fast-path is now written in terms of verifiable code (Span and ReadOnlySpan).
- Minor bug fixes in EncoderNLS.Convert (see https://github.com/dotnet/coreclr/issues/23020).

Signed-off-by: dotnet-bot <[email protected]>
2019-03-11 09:05:29 +01:00
monojenkins db6ee0108b [bcl] Update BCL Linked Size 2019-03-11 09:01:51 +01:00
Bernhard Urban 2eeaf888c1 [AOT] add option to control arguments to llc and add fallback for x86 (#13323)
* [AOT] add option to control arguments to llc and add fallback for x86

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

* rename
2019-03-11 08:40:22 +01:00
Kenneth Pouncey 24a0e0d7f2 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-03-11 06:23:29 +01:00
monojenkins 3489679dc5 Bump API snapshot submodule 2019-03-10 13:11:12 +01:00
Steve Pfister 063f2a2b9a Added missing ToolLocationHelper methods that will be
used by refsrc System.Web.Compliation.AssemblyResolver.
2019-03-10 13:11:12 +01:00
Larry Ewing 5dbf642965 Add Blazor E2E test to wasm bcl-size-diff 2019-03-10 13:11:01 +01:00
Kurt Van Dijck 3e8108ea65 threads: set mutex PRIO_INHERIT in attribute (#13333)
threads: set mutex PRIO_INHERIT in attribute

When running multiple threads on a linux-rt kernel, with different priorities, the lack of priority-inheritance
makes the kernel make wrong scheduling choices.
This commit changes the system-wide mutex initializers.
This change protects our system against unexpected latencies in higher priority threads.

<!--
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
-->
2019-03-09 23:35:34 -05:00
Marek Safar 4259cfad8f Remove local Buffer copy 2019-03-10 00:56:08 +01:00
Egor Bogatov 8a3a41b81a Move Buffer to shared (dotnet/coreclr#23157)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-10 00:56:08 +01:00
Dan Moseley 73caa49efb Remove 2 suffix step 1 (dotnet/corefx#35904)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-10 00:56:08 +01:00
Stephen Toub d5b0333f37 Add stack depth check to all Task continuations (dotnet/coreclr#23152)
Currently Task has a stack depth check that avoids stack overflows on very deep stack continuation chains, but it only applies to Task.ContinueWith, not to other kinds of continuations.  This changes that to have it apply to all.

As part of this, this also deletes the current StackGuard type used to achieve the check.  The type was meant to avoid expensive calls to check where we are on the stack, but now that we're using TryEnsureSufficientExecutionStack, it's actually faster to just call that rather than access the current StackGuard from a ThreadLocal.  This then also cleans up the call sites nicely, as they no longer need finally blocks to undo the increment performed on the StackGuard.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 17:48:20 +01:00
Zoltan Varga 92dfcb120b [netcore] Use codedom for code emission in the xunit generator. Add support for Theories and inline data. 2019-03-09 11:52:49 +01:00
Zoltan Varga 0f798ae6cf [netcore] Ongoing work. (#13357)
* [netcore] Implement MethodBody using internal Runtime* classes. Use the mono version for ModuleHandle.

* [netcore] Reflection fixes.

* Address review comments.

* [netcore] Implement RuntimeHelpers:GetUninitializedObject ().

* [netcore] Implement the Type::GetMethod () overload which has a genericParameterCount parameter.

* [netcore] Implement Thread.OptimalMaxSpinWaitsPerSpinIteration.

* Revert a change to fix a test failure.

* [netcore] Implement Marshal:GetExceptionForHRInternal ().

* [netcore] Implement GC:GetSegmentSize ().

* [runtime] Allow pointer type members in typed references.
2019-03-09 05:26:40 -05:00
Marek Safar dd0e9a8aa3 Fix the build 2019-03-09 09:27:46 +01:00
Marek Safar 289eb40af4 Move part of RuntimeHelpers to shared partition (dotnet/coreclr#23130)
* Move part of RuntimeHelpers to shared partition

* Remove FormatterServices.cs

Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 09:27:46 +01:00
Steve Pfister 0306c38fed Add refsrc DataProtector to System.Security (#13365)
* Added DataProtector abstract class to be used when refsrc
System.Web gets ported over.

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-09 01:07:53 +01:00
Zoltan Varga 4401acd172 [jit] Avoid an assert with default interface methods and gsharing.
Fixes https://github.com/mono/mono/issues/13319.
2019-03-09 00:55:39 +01:00
Dotnet-GitSync-Bot 8efb2906d2 Mirror changes from mono/coreclr,corert (#13375)
* Added new Range Manipulation APIs for Collection<T> which propogate up to ObservableCollection<T>. AddRange, InsertRange, RemoveRange and Replace Range

Signed-off-by: dotnet-bot <[email protected]>

* Updated index out of range exception check to be a single comparison

Signed-off-by: dotnet-bot <[email protected]>

* Updated foreach to use T instead of var

Signed-off-by: dotnet-bot <[email protected]>

* Adding braces on for loop

Signed-off-by: dotnet-bot <[email protected]>

* Added ReplaceItemsRange API and updated ReplaceRange to invoke the protected method

Signed-off-by: dotnet-bot <[email protected]>

* Remove ternary operator from invocation as it is the same as inputing items.Count

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveItemsRange to prevent int.MaxValue overflow errors

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveItemsRange to properly remove each item and not just the index items

Signed-off-by: dotnet-bot <[email protected]>

* Added ArgumentOutOfRangeException exception in RemoveRange if the count is less than 0

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveRange invocation of RemoveAt to use index instead of i, because the array changes with each iteration of the for loop and will cause side-effects which may include index out of range exceptions. This needs to be index because as the array shrinks the index is always at the correct position.

Signed-off-by: dotnet-bot <[email protected]>

* Updated RemoveAt->RemoveItem. This change removes redundent validation checks that happen using the RemoveAt API. RemoveItem gives us direct access to invoke the command

Signed-off-by: dotnet-bot <[email protected]>

* Updated InsertItemsRange to simplify the expression and added performance improvements. If the underlying `items` is using List<T> we should use it's InsertRange method since it is optimized, othersie we use InsertItem

Signed-off-by: dotnet-bot <[email protected]>

* Added new RemoveRange validation check to see if the resulting range (index + count) > items.Count and if it is true throw ArgumentException

Signed-off-by: dotnet-bot <[email protected]>

* Removed (Int64) cast statements from RemoveItemsRange when checking for overflow errors

Signed-off-by: dotnet-bot <[email protected]>

* InsertItemsRange API now checks if the underlying items.IsReadOnly first then collection == null

Signed-off-by: dotnet-bot <[email protected]>

* Simplified the RemoveItem logic since we have more robust validation

Signed-off-by: dotnet-bot <[email protected]>

* Optimized RemoveItemsRange to call the list.RemoveRange if the items is of type List<T>

Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 00:51:26 +01:00
Filip Navara 19258e1680 Allow deserialization for ResourceManager created with non-default resource set type (#23051)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-09 00:44:14 +01:00
Johan Lorensson 2e30dbab63 Correctly defined thread API support for different Windows platforms. (#13344) 2019-03-08 14:34:49 -05:00
Zoltan Varga 6c81f5dbd2 [sdb] Avoid stack overflows caused by recursive calls between suspend_current () and invoke_method (). (#13362)
Fixes https://github.com/mono/mono/issues/13261.
2019-03-08 14:20:36 -05:00
Johan Lorensson 4c57215ca9 Fix GetTokenName to fail with exception on none Windows desktop platforms. (#13343) 2019-03-08 12:38:56 -05:00
Johan Lorensson 526939e146 Better probing logic on Windows when Unicode Win32 symbols are used. (#13345)
Several of the corefx interop sources uses the Unicode names of Win32 symbols.
Our current probing implementation on Windows will test the given name last
when nomangle is not provided (default). On Windows that will be a large number
of probes due to old stdcall name mangling rules. Fix makes sure we first test
the symbol against its charset and the given symbol, before trying the stdcall
name mangling rules. Will reduce the probing a lot on Windows for corefx Win32
interop classes.
2019-03-08 12:35:56 -05:00
Larry Ewing 27197d3f15 Add System.Runtime.Serialization targets 2019-03-08 10:36:31 -06:00
Larry Ewing f2b8ec3b3d Move the disabled tests under INCLUDE_DISABLED 2019-03-08 10:36:31 -06:00
Larry Ewing ad4e0414cd Add DataContractSerializer test 2019-03-08 10:36:31 -06:00
Larry Ewing a7f4dea649 Add linker test for Queryable 2019-03-08 10:36:31 -06:00
Alexander Köplinger 566e4565f4 [corlib] Remove Interop.MountPoints.cs from .sources (#13363)
* [corlib] Remove Interop.MountPoints.cs from .sources

We no longer need it since https://github.com/mono/mono/pull/13125 and having
it included makes xamarin-macios still complain about the missing symbol.

* [csproj] Update project files
2019-03-08 17:19:09 +01:00
lateralusX 7014dc1f8c Fix LLVM Dwarf CFI on Windows x64. Bump to corresponding LLVM commit. 2019-03-08 16:33:17 +01:00
lateralusX 5d5cb61243 Fix build warning in mono-error.h.
Warning (at least on Windows) due to unamed struct:

C4201, nonstandard extension used : nameless struct/union

Since the header can be consumed by embedders this warning should be
disabled.
2019-03-08 16:11:14 +01:00
lateralusX e9183496fb Include mono-forward.h public header on Windows. 2019-03-08 15:35:10 +01:00
Kenneth Pouncey e0651ded29 Add exclude features option when linking to the sdk. (#13340) 2019-03-08 15:22:36 +01:00
Johan Lorensson f89fdf28a3 Fix build warning in full AOT build. (#13342) 2019-03-08 06:37:46 -05:00
Marek Safar 63a58325b5 Remove unused type 2019-03-08 09:50:42 +01:00
Marek Safar 841a1d49b7 Use platform specific implementation of GetCurrentProcessId (#23084)
* Use platform specific implementation of GetCurrentProcessId

directly in shared location instead of relying on runtime export

* Move GetCurrentProcessId to Interop class

* Update ES_BUILD_STANDALONE build

Signed-off-by: dotnet-bot <[email protected]>
2019-03-08 09:50:42 +01:00
Marek Safar 14b0f985de Merge pull request #13356 from monojenkins/bclsizediff
[bcl] Update BCL Linked Size
2019-03-08 09:38:42 +01:00
Jb Evain 297b6ba328 [sdb] Avoid double lookup of replay packets 2019-03-08 09:34:54 +01:00
Dávid Kaya 8fc751180c Added UserFlags field, unblocks #34560 (dotnet/corefx#35851)
* Added UserFlags field

* Added UserFlags

Signed-off-by: dotnet-bot <[email protected]>
2019-03-08 07:39:21 +01:00
monojenkins b5daa32188 [bcl] Update BCL Linked Size 2019-03-08 03:38:14 +00:00
Alexander Köplinger 8cd69e14e3 Update System.Net.Http.csproj
Change missed in https://github.com/mono/mono/commit/97adf2e53e20c127bc38cb4f64a43f55c77e5c7e
2019-03-07 23:41:22 +01:00
Stephen Toub ad819c8921 Add missing CopyToAsync override in FileStream.Unix.cs (#23101)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 23:38:17 +01:00
Zoltan Varga 11349df4e6 [netcore] Add a tool to convert corefx test assemblies into simple test runners. (#13346)
* [netcore] Add a tool to convert corefx test assemblies into simple test runners.

* Fix computation of traits.
2019-03-07 22:50:42 +01:00
Hugh Bellamy f6179a0e68 Cleanup Globalization info code (dotnet/coreclr#22591)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 22:24:52 +01:00
Martin Baulig 97adf2e53e HttpClient for Web Assembly. 2019-03-07 21:49:27 +01:00
Alexander Köplinger 2e4d4a040c [sqlmetal] Distribute DbLinq.snk in tarball 2019-03-07 19:05:05 +01:00
monojenkins dbcd755c86 Bump API snapshot submodule 2019-03-07 18:47:03 +01:00
monojenkins ebb8b6fff2 [csproj] Update project files 2019-03-07 18:47:03 +01:00
Martin Baulig 2d6f02a83c HttpClient for Android. 2019-03-07 18:47:03 +01:00
Vlad Brezae deebdd1489 [interp] Add a few starting stats (#13347)
* [runtime] Use same single convention for stats tracking time

Also avoid useless mallocs/frees

* [interp] Add counters for transform phase
2019-03-07 11:53:11 -05:00
Kenneth Pouncey cad455b393 Fix HttpMessageHandler request content as binary. 2019-03-07 11:50:09 +01:00
Alexander Köplinger f77193d306 [mono/tests] Add fullaot-mixed to SUBDIRS
Fixes tarball build break.
2019-03-07 11:43:56 +01:00
Kenneth Pouncey 8d12c53c0a Fix ClientWebSocket passing of ArraySegment. 2019-03-07 11:35:16 +01:00
Kenneth Pouncey bb5eb13967 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays
# Conflicts:
#	sdks/wasm/framework/src/WebAssembly.Bindings/WebAssembly.Bindings.csproj
2019-03-07 10:10:59 +01:00
monojenkins 7fe2472b34 [csproj] Update project files 2019-03-07 10:03:14 +01:00
monojenkins 530596db02 Bump API snapshot submodule 2019-03-07 10:03:14 +01:00
Steve Pfister 6a9950c5d2 * System.Data.Linq now points to reference source
* Created SR and Strings helpers as refsrc resources are
  missing / incomplete

* Moved existing tests into the Test folder

* Moved old DBLinq code into tools/sqlmetal as there are no other
  alternatives.
2019-03-07 10:03:14 +01:00
Marek Safar c96df417d1 Remove code moved to shared 2019-03-07 00:42:25 +01:00
Tanner Gooding 57c75cbb94 Fixing the float/double parsing logic to handle exponents that are too large/small (#23043)
* Fixing the float/double parsing logic to handle exponents that are too large/small

* Fixing the debug assert to use >= and <=

* Fixing the max exponents to be +1 to match what scale uses.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Stephen Toub 6d8df4e7f3 Clean up some string.Format usage (dotnet/coreclr#23025)
* Clean up some string.Format usage

Mainly changes some string.Format usage to be SR.Format when working with resource strings.  Also cleans up a few asserts that were using string.Format.

* Address PR feedback and clean up src

* Address more feedback

* Update src/System.Private.CoreLib/shared/System/Type.Enum.cs

Thanks.

Co-Authored-By: stephentoub <[email protected]>
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Maryam Ariyan d56e47721a Add Type Forward (dotnet/coreclr#23036)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Marek Safar 72406ff802 Move more Assembly methods to shared partition (dotnet/coreclr#22817)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Andrew Au a7963f4e51 Fix issue 23009
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Honza Rameš d1b1ce9dfa Fix ValueStringBuilder.EnsureCapacity to call Grow correctly (#35810)
* Fix ValueStringBuilder.EnsureCapacity to call Grow correctly (#35746)

Call to EnsureCapacity may result in invalid buffer size being
allocated.

* Update ValueStringBuilder.Grow to prevent misuse (#35746)

Updated name of the argument to make it clearer on the call-site also
added summary co clearly state the behavior of Grow.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
dotnet-maestro[bot] 60de375154 Update dependencies from dotnet/core-setup (dotnet/corefx#35713)
* Update dependencies from https://github.com/dotnet/core-setup build 20190301.13

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27501-13
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27501-13
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27501-13

* Remove workaround for System.Runtime.CompilerServices.Unsafe

* Update dependencies from https://github.com/dotnet/core-setup build 20190302.8

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27502-8
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27502-8
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27502-8

* Update dependencies from https://github.com/dotnet/core-setup build 20190303.9

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27503-9
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27503-9
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27503-9

* Update dependencies from https://github.com/dotnet/core-setup build 20190304.10

This change updates the following dependencies
- Microsoft.NETCore.App - 3.0.0-preview4-27504-10
- Microsoft.NETCore.DotNetHost - 3.0.0-preview4-27504-10
- Microsoft.NETCore.DotNetHostPolicy - 3.0.0-preview4-27504-10

* Don't include EventRegistrationToken on Unix

This type was accidentally duplicated between CoreLib and contracts.

Suppress that for now since we're detecting the duplication in the shared framework.

Make a fix in the shared items to restore the condition on this type.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Viktor Hofer af3965d9d2 Project msbuild syntax cleanup (dotnet/corefx#35686)
* Remove license header from non-shipping files

* Remove obsolete Project attributes

* Remove xml header and remove DefaultTargets

Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Michal Strehovský edf4941ec3 Fix ProjectN build breaks (dotnet/corert#7115)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Marek Safar 186ae08b0a Move fully managed TimerQueue implementation to shared partition (#7111)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-07 00:42:25 +01:00
Alexander Köplinger 97f2393f3e [mono/tests] Add common_mixed.mk to EXTRA_DIST 2019-03-06 23:58:48 +01:00
Alexander Köplinger 2f2881fc4b Add .gitignore for mono/tests/fullaot-mixed 2019-03-06 23:56:11 +01:00
Alexander Köplinger aabd3ab102 Bump bockbuild to get GTK fix
See https://github.com/mono/bockbuild/pull/90
2019-03-06 23:45:10 +01:00
Marek Safar fbffa8719a [System.Private.CoreLib] Fix the build 2019-03-06 23:05:20 +01:00
Martin Baulig 6034bc00c4 Introducing HttpClient.CreateDefaultHandler(). (#13305)
* The default `HttpClient` constructor now calls a static method `CreateDefaultHandler()`;
   we provide a platform-specific implementation of it.

* Replaced `HeaderUtils` with `PlatformHelper` and removed the `LEGACY_HTTPCLIENT` conditional.

* Added a new `socketshandler.sources` file to keep the sources in one place.

* Use a reflection check in the tests instead of the `LEGACY_HTTPCLIENT` conditional.

* This allows us to also get rid of the `SOCKETSHTTPHANDLER` define.
2019-03-06 20:56:42 +01:00
Zoltan Varga 835c8590ca [netcore] Implement DependentHandle using the existing ephemeron code. 2019-03-06 18:24:46 +01:00
Katelyn Gadd d02c43e23e Propagate type load errors out of IsAssignableFrom instead of erroneously returning false. Makes the underlying cause of #13113 discoverable. (#13324) 2019-03-06 11:41:55 -05:00
Ludovic Henry 6527e21bb4 [safepoint] Use LLVM pass to insert safepoint (#11789)
* [safepoint] Use LLVM pass to insert safepoint

This is to avoid safepoints to stop optimizations from happening.

* [safepoint] Use LLVM pass to insert safepoint

This is to avoid safepoints to stop optimizations from happening.

* fix error: emit_gc_safepoint_poll does not return anything

* Revert partial 4150f06f8621f2f2918e3bd747bf80a0f0f8c9c6

* Fix build

* [runtime] Add mono_threads_state_poll to preinited icalls

* [runtime] Adding back in safepoint icall skip code

* Revert mini.c to 100f422

* [runtime] Add missing deref to safepoint poll

* [runtime] Make safepoint functions have WeakODR linkage
2019-03-06 11:38:48 -05:00
Alexander Köplinger cacc9b7c4c [Facades] Add typeforwarders for DispatchProxy and TypeExtensions (#13325)
* [Facades] Add typeforwarders for DispatchProxy and TypeExtensions

DispatchProxy lives in System.Core for all profiles since https://github.com/mono/mono/pull/13198.

TypeExtensions live in corlib since https://github.com/mono/mono/pull/9746.

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-06 16:20:51 +01:00
Zoltan Varga 2b761f9ea5 [linker] Only preserve the m_value fields of the primitive types. 2019-03-06 11:34:34 +01:00
Egor Bogatov e42bf95d14 NS2.1 Sync new changes, mobile profiles (#13198)
* Add RuntimeHelpers.GetSubArray. Add missing types to NS's TypeForwarders.cs

* more NS2.1 changes

* ios changes

* Update Decimal (it's now readonly struct)

* fix mcs

* add ROMC.cs

* Fix tests, finish monodroid profile

* Make SRE-not-supported NS2.1 compatible

* Make monotouch_tv and watch NS2.1 compatible

* make some SRE types more NS21 compatible (non-abstract now)

* bump corefx

* More NS21 fixes

* bump coreclr acceptance tests

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-06 08:55:16 +01:00
Alexander Köplinger b31a445e85 [gitattributes] Do CRLF normalization on sln/proj files
They can be used with native line endings.

We now have a shared folder with the dotnet repos and they have CRLF normalization enabled.
This difference leads to conflicts while applying changes from the dotnet repos to mono.
2019-03-06 08:34:01 +01:00
justremotephone eb3f7312bd [System.ServiceModel] Fix a race condition in HttpRequestChannel. (#13304)
Concurrent request completions could cause following exception:

```
    FATAL UNHANDLED EXCEPTION: System.ArgumentOutOfRangeException:
        Index was out of range. Must be non-negative and less than
        the size of the collection.
        Parameter name: index
       at System.Collections.Generic.List`1[T].RemoveAt (System.Int32 index) [0x00009] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Collections.Generic.List`1[T].Remove (T item) [0x0000c] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.ServiceModel.Channels.HttpRequestChannel+HttpChannelRequestAsyncResult.Cleanup () [0x00011] in <28c4695205ef47378f5370502b066592>:0
       at System.ServiceModel.Channels.HttpRequestChannel+HttpChannelRequestAsyncResult.set_IsCompleted (System.Boolean value) [0x00034] in <28c4695205ef47378f5370502b066592>:0
       at System.ServiceModel.Channels.HttpRequestChannel+HttpChannelRequestAsyncResult.Complete (System.Exception ex) [0x0001a] in <28c4695205ef47378f5370502b066592>:0
       at System.ServiceModel.Channels.HttpRequestChannel+<>c__DisplayClass7_1.<BeginProcessRequest>b__0 (System.IAsyncResult r) [0x000bd] in <28c4695205ef47378f5370502b066592>:0

    This stack was captured after some changes in AwaitTaskContinuation.RunOrScheduleAction.
    Unfortunately the current implementation of AwaitTaskContinuation.RunOrScheduleAction re-throws the above
    exception with a wrong stack:

       at System.Threading.Tasks.AwaitTaskContinuation.RunOrScheduleAction (System.Action action, System.Boolean allowInlining, System.Threading.Tasks.Task& currentTask) [0x00023] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishContinuations () [0x00052] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishStageThree () [0x0003c] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishStageTwo () [0x000a1] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.Finish (System.Boolean bUserDelegateExecuted) [0x00003] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.TrySetException (System.Object exceptionObject) [0x00023] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetException (System.Exception exception) [0x00029] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Net.HttpWebRequest+<RunWithTimeoutWorker>d__241`1[T].MoveNext () [0x000e0] in <3e9b3e26c4694baab3f689687ad40612>:0
       at System.Runtime.CompilerServices.AsyncMethodBuilderCore+MoveNextRunner.InvokeMoveNext (System.Object stateMachine) [0x00000] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.ExecutionContext.RunInternal (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) [0x00071] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.ExecutionContext.Run (System.Threading.ExecutionContext executionContext, System.Threading.ContextCallback callback, System.Object state, System.Boolean preserveSyncCtx) [0x00000] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Runtime.CompilerServices.AsyncMethodBuilderCore+MoveNextRunner.Run () [0x00024] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.AwaitTaskContinuation.RunOrScheduleAction (System.Action action, System.Boolean allowInlining, System.Threading.Tasks.Task& currentTask) [0x00023] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishContinuations () [0x00052] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task.FinishStageThree () [0x0003c] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Threading.Tasks.Task`1[TResult].TrySetResult (TResult result) [0x0004f] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[TResult].SetResult (TResult result) [0x0003d] in <4a8a0eaa024f41829d3435c07e5c7edb>:0
       at System.Net.ServicePointScheduler+<WaitAsync>d__45.MoveNext () [0x000f7] in <3e9b3e26c4694baab3f689687ad40612>:0
       at System.Runtime.CompilerServices.AsyncMethodBuilderCore+MoveNextRunner.InvokeMoveNext (System.Object stateMachine) [0x00000] in <4a8a0
```

On an Android Xamarin installation this causes an app crash. Since no user code is active the exception cannot be caught.
2019-03-06 01:07:29 +01:00
Alexander Kyte 24c637dd26 Merge pull request #13262 from alexanderkyte/fixup_no_threads
[crash] Detect when 0 attached threads, fix hang/double-fault.
2019-03-05 17:38:16 -05:00
Maxim Lipnin 0e9495a034 Get fully qualified name of ModuleBuilder (#13308)
* Get fully qualified name of ModuleBuilder

* Use MethodBuilder.FileName to find main module
2019-03-05 16:20:47 -05:00
Kenneth Pouncey 9330096912 [wasm][ci]Update to latest JavaScript (engine) Version Updater (#13307)
- The purpose of this is to be able to respond to CI incidents faster for instance specific engine versions when JavaScript engines do not update/install correctly.
- This will install from a forked version of the jsvu repo: https://github.com/GoogleChromeLabs/jsvu
- Forked version rests here:  https://github.com/kjpou1/jsvu/tree/mono-wasm
   - The forked version removes the Node >= 10.0 dependency but brings in the newest 1.4.0 version modifications.
- This should be temporary until we get another solution i.e. a managed version of the engine updater.
2019-03-05 17:08:45 +01:00
Alexander Köplinger d99af881c3 [corlib] Disable ThreadPoolTest.GetAvailableThreads () on machines with many cores
It doesn't work well on the new 64 core ARM machines we have in CI.
2019-03-05 14:33:26 +01:00
Zoltan Varga af87454146 [jit] Avoid an assert when gsharedvt enums are boxed. (#13301)
Fixes https://github.com/mono/mono/issues/13297.
2019-03-05 01:21:02 -05:00
Alexander Köplinger c2a1eb5de6 [corlib] Improve ThreadPoolTest.GetAvailableThreads ()
Don't print console output in the loop and bump timeout.
2019-03-05 01:44:07 +01:00
Zoltan Varga 819660ef97 [netcore] Ongoing work.
* Implement all CustomAttributeExtensions methods.
* Add stubs for __ComObject which is needed by the runtime.
2019-03-04 19:33:46 +01:00
monojenkins 24d55fb184 [master] Fix mono conc hashtable lookup endless loop (#13292)
Fix mono conc hashtable lookup endless loop
2019-03-04 13:11:55 -05:00
monojenkins ef30f5589b [bcl] Update BCL Linked Size 2019-03-04 18:40:41 +01:00
Aaron Hill 290b537a73 Ensure that the module cctor is run before the entry point is executed (#13242)
* Ensure that the module cctor is run before the entry point is executed

We need to ensure that any module cctor for the 'main' image
is run *before* we invoke the entry point

This is required in order for tools like Costura
(https://github.com/Fody/Costura) to work properly. These tools inject
a module initializer which sets up event handlers (e.g. AssemblyResolve),
which allows the main method to run properly

For more information about module constructors,
see https://blogs.msdn.microsoft.com/junfeng/2005/11/19/module-initializer-a-k-a-module-constructor/

* Fix module-cctor-entrypoint.il
2019-03-04 12:31:17 -05:00
Alexander Köplinger e8fbaa5531 [linker] Fix monotouch tests which need Xamarin.iOS.dll (#13287)
The linker couldn't resolve Xamarin.iOS.dll which System.Net.Http references now.
2019-03-04 17:46:56 +01:00
Egor Bogatov af6d863e52 [corlib] Fix Directory.GetLogicalDrives () (#13125)
Fixes #13030
2019-03-04 16:43:46 +01:00
sancheolz 89f264ad86 [SWF] Method OnClosed should pass FormClosedEventArgs type, instead of EventArgs.Empty (#13283)
Fixes #13282
2019-03-04 15:31:59 +01:00
Bernhard Urban 1da9c0f9e7 [interp] mixed mode fixes for delegates (#13215)
* [interp] avoid multiple transformations

* [interp] remove delegate hack for method_ptr=imethod case

it isn't needed anymore

* [interp] ensure initialized fields of a class retrieved from wrapper data

* [fullaot mixed] add test for specific mixed mode scenario

* [interp] remove assertion, it does not take into account multiple threads transforming the same method

* [interp] avoid non-lazy compilation of delegate if interpreter is involved

* [fullaot-mixed] disable on i386

* [interp] propagate errors on delegate init

* fix c++ build

* [tests] improve return codes

* error only for dynamic methods

* [fullaot-mixed] disable test on coop
2019-03-04 15:06:35 +01:00
sancheolz bac5347996 [System.Runtime.Remoting] Implement CustomErrorsMode for RemotingConfiguration (#13251)
Implemented property RemotingConfiguration.CustomErrorsMode.

Fixes #13250
2019-03-04 15:01:40 +01:00
Marek Safar a08eff03f7 [System.Private.CoreLib] Implement more APIs 2019-03-04 12:58:03 +01:00
Zoltan Varga 85c8e85476 [netcore] Ongoing work. (#13278)
* Implement CustomAttributeExtensions methods.
* Add a AssemblyFileVersion attribute.
* Don't try AppDomain.TypeResolve.
2019-03-04 11:59:37 +01:00
Zoltan Varga f82ae71c90 [netcore] Fix threading. 2019-03-03 13:42:10 +01:00
Zoltan Varga 6b6b1ce35e [jit] Fix the RuntimeHelpers.ObjectHasComponentSize () intrinsics. (#13271) 2019-03-03 06:58:11 -05:00
Jan Kotas 9bdb423e5d Fix CoreCLR build break
Signed-off-by: dotnet-bot <[email protected]>
2019-03-03 12:12:26 +01:00
Jan Kotas 6578e93670 Update CoreRT for changes in shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-03-03 12:10:25 +01:00
Marek Safar 519139773f Fix the build 2019-03-03 12:01:00 +01:00
Marek Safar 243d669a2e Move Activator to shared partition (dotnet/coreclr#22894)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-03 12:01:00 +01:00
Grant d8e9e8fa6d Use BitOperations in more callsites (CoreCLR) (dotnet/coreclr#22630)
* Missed perf improvement in EventProvider

* Add missing methods to StubEnvironment

Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 23:07:39 +01:00
Jan Kotas 84d6476152 Fix CoreFX build break
Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 21:10:37 +01:00
Jan Kotas a31af4add7 Fix netfx build break
Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 21:10:37 +01:00
Alexander Köplinger 64556b9bb9 [ci] Shorten timeout in SDKs tests
The tests normally complete in a few mins.
2019-03-02 12:46:27 +01:00
Calvin Buckley 2ecf08d265 More PPC/AIX regression fixes (#13264)
* Fix System.Math regressions brought on by PowerPC JIT optimizations

	* While frin[.] does do rounding, the semantics are slightly
	  different enough from the BCL that it subtly breaks, as
	  seen by some tests. Ceil/Floor/Trunc are fine, however.
	  Perhaps the sysmath.c version can be translated to asma.

	* Fix typo where signed long comparison for isel was using
	  an unsigned comparison.
	  Add a test for this in the JIT regression check.

* Link against (not fd.o) libbsd for System.Native on AIX

The way we link the library by default will allow some unresolved
symbols. These will get resolved to the runtime when loaded by it.
However, flock isn't in AIX libc, and the native library needs it.
This doesn't seem to be a problem on AIX, but on i libbsd doesn't
seem to be in the dependency chain, so it errors out when you use
it. The workaround is to link libbsd (not the freedesktop.org one)
into the library. According to dump, it seems it has its own copy
of ioctl and fnctl, but they seem benign according to objdump and
don't seem to affect System and corlib tests I've ran to check it.
2019-03-02 12:43:12 +01:00
Marek Safar 30d70e98e6 Fix the build 2019-03-02 11:05:00 +01:00
Morgan Brown 580f5ef53a Implement Serialization Guard
Add Serialization Guard API and consume it in CoreLib targets

Signed-off-by: dotnet-bot <[email protected]>
2019-03-02 11:05:00 +01:00
Maxim Lipnin ed0d055424 Throw InvalidOperationException if inner handler is not assigned 2019-03-02 02:31:54 +01:00
Alexander Kyte db5d8729b4 [crash] Detect when 0 attached threads, fix hang/double-fault. 2019-03-01 16:11:11 -05:00
Zoltan Varga 4970e055b3 [netcore] Implements threads. (#13245)
* [netcore] Implements threads.

There is only one thread object, since there are no domains.

* Make the start callback internal.
2019-03-01 15:15:31 -05:00
Ludovic Henry 234daf1cf3 [android] Fix Mono.Debugger.Soft tests with Android SDKs (#13218)
* [android] Fix Mono.Debugger.Soft tests with Android SDKs

* [android] Fix connecting with LLDB

* [android] Add scaffolding to run profiler tests

* [android] Fix some corlib tests

* [android] Fix Mono.DebuggerTests.ExceptionFilter2

* [csproj] Update project files
2019-03-01 21:03:26 +01:00
Rolf Bjarne Kvinge c99fe4b462 [mini] Inline Selector.GetHandle for tvOS and watchOS assemblies as well. (#13246) 2019-03-01 11:10:04 -05:00
monojenkins 83d5cf0c5c [android] Fix inaccurate detection of sendfile() (#13243)
[android] Fix inaccurate detection of sendfile()
2019-03-01 10:28:34 -05:00
Alexander Kyte 23c83a48cd [runtime] Optimize array_set_value_impl slow path (#13186)
* [runtime] Add unmanaged fast-path for mono_class_is_assignable_from

Our managed code has a fast path for this that checks if the two types
are the same. The unmanaged calls here always falls back on the slow path.

This leads to a latency that is pretty observable during
array_set_value_impl calls.

* [runtime] Make faster already-pinned nullable init path

* [runtime] Expose non-handle-allocating object_handle_isinst_mbyref

* [runtime] Use MONO_ENTER_NO_SAFEPOINTS for array_set_value_impl
2019-03-01 10:21:02 -05:00
Vlad Brezae e4b281825a [interp] Add fast paths for common cast checks (#13225)
* [interp] Remove some duplicated code

* [interp] Optimize type checking for interfaces

Mainly to avoiding handles for common scenarios. Makes type checking for common interfaces 10x faster.

* [interp] Optimize type checking for common classes

Mainly to avoiding handles for common scenarios. Makes type checking for common classes 10x faster.
2019-03-01 10:19:12 -05:00
Alexander Köplinger 98e0f2697d [sdks] Use throttle() instead of lock()
The former works in freestyle builds.
2019-03-01 14:45:16 +01:00
Alexander Köplinger f5b9af2505 Revert "[sdks] Make sure to run only one build per type per node"
This reverts commit b740313aa5.

We actually want to only run one build per product on a node,
e.g. so that android-debug and android-release can't run on
the same node and stomp on each other's toolchain.
2019-03-01 13:57:06 +01:00
Alexander Köplinger 793c3aa3aa [ci] Add node name to log of Jenkins pipeline builds
Makes it easier to figure out where a build ran.
2019-03-01 13:31:01 +01:00
Alexander Köplinger 5bf74a9954 [System.Net.Http] Move NSUrlSessionHandler from xamarin-macios to mono (#13229)
* [System.Net.Http] Move NSUrlSessionHandler from xamarin-macios to mono

This allows us to remove the need for a special custom System.Net.Http.dll
build in the xamarin-macios repository.

Part of #11397

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-01 12:20:27 +01:00
Katelyn Gadd 6c58376102 If a ClientIdentity has no ClientProxy then return null from the accessor instead of throwing. Experimental partial fix for issue #13113 2019-03-01 11:59:50 +01:00
Levi Broderick fcbc8c3792 Add Rune.DecodeUtf16 / DecodeUtf8 and friends (dotnet/coreclr#22725)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 09:57:09 +01:00
Aaron Robinson 3508069707 Move COM related attributes to the shared source location of Object class. (#22942)
Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 09:57:09 +01:00
Tanner Gooding 5b02347ae8 Removing the ExtractVector128 and InsertVector128 APIs that take an address. (#22886)
* Removing the InsertVector128 and ExtractVector128 overloads that take an address from S.P.Corelib

* Removing the ExtractStore and InsertLoad tests.

* Fixing the PacketTracer test to use the appropriate Extract/InsertVector128 overloads

* Removing the JIT support for the Extract/InsertVector128 overloads that take an address.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 09:54:21 +01:00
monojenkins 041e874182 [bcl] Update BCL Linked Size 2019-03-01 09:32:07 +01:00
Alexis Christoforides adc62b328e [monodroid] Use CoreFX to implement System.Drawing types that used to be in Mono.Android.dll (#13135)
* [monodroid] Use CoreFX to fill in reference stubs for System.Drawing types that are currently 'forked' from Mono into Mono.Android.dll

The list of localy implemented System.Drawing types: https://github.com/xamarin/xamarin-android/blob/e0da1f152de84c4cc39983f2fda775ec98c08250/src/Mono.Android/Mono.Android.csproj#L311-L325

* [netstandard] Update for Mono.Android change

* Bump reference assemblies to include Mono.Android update

* Use System.Drawing.Common to find moved types in monodroid case for netstandard facade

* Bump API snapshot submodule

* [csproj] Update project files
2019-03-01 01:50:44 +01:00
Alexander Köplinger 4ea57007fa [Mono.Debugger.Soft] Disable Attach() test that fails or hangs (#13239)
It was recently reenabled in #9091 but it fails/hangs frequently.
2019-03-01 01:43:19 +01:00
Aaron Robinson b5d6e5344f Set the MarshalByRefObject to be ComVisible and (dotnet/coreclr#22930)
a IDispatch class interface. this is being done
  to ensure WinForms consumers can interact with
  COM based controls.

Signed-off-by: dotnet-bot <[email protected]>
2019-03-01 00:28:08 +01:00
Stephen Toub b0935ae258 Fix DumpAsync to understand ContinuationWrapper (dotnet/coreclr#22913)
Continuations created while the debugger is attached or certain EventSource events are enabled end up getting wrapped in an extra ContinuationWrapper object that carries some additional information.  DumpAsync currently isn't unwrapping these but should.  This just teaches it to look for a known field name so that it can "see through" these wrappers while following async "stacks".

Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:30:53 +01:00
Marek Safar a88ad66551 Build fixes 2019-02-28 23:05:24 +01:00
Jan Kotas 51a4aae4ff Fix CoreRT build break
Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:05:24 +01:00
Stephen Toub ee67c17eb3 Address PR feedback (clean up style in Thread.CoreCLR.cs)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:05:24 +01:00
Stephen Toub 54d2a05d66 Fix Thread-related breaking changes
- Thread.ExecutionContext needs to return ExecutionContext.Capture() to public callers.
- Fix restoring of culture to be inside of the ExecutionContext callback where applicable

Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 23:05:24 +01:00
Marek Safar 4c4421f30d Fix the build 2019-02-28 22:41:40 +01:00
Filip Navara d14b15f502 Move Thread to shared CoreLib (dotnet/coreclr#22744)
* Move Thread to shared CoreLib

* Remove all local variables from Thread in shared code

* Remove duplicate checks

* Port back CoreRT changes needed for shared code

* Fix missing culture initialization in ThreadStart()

* Adjust for shared WaitHandle

Signed-off-by: dotnet-bot <[email protected]>
2019-02-28 22:41:40 +01:00
Johan Lorensson 80e5e7ff62 Cancel sync IO on Windows when aborting thread. (#13173)
* Cancel sync IO on Windows when aborting thread.

Using CancelIO/CancelIOEx or CancelSynchronousIo on a thread that is moving
into a suspended state can cause these calls to hang (they shouldn’t but
have been observed to be the case). Fix does the cancel of sync IO after
the aborted thread has been resumed, but before releasing suspend locks
making sure thread won't be suspend again until after cancel IO call has
completed.

* Add tests aborting blocking socket and file IO on Windows.
2019-02-28 16:02:21 -05:00
Alexander Köplinger e3caf01677 [sdks] Use abspath instead of PWD on iOS app build (#13230)
PWD is the wrong directory when e.g. you're doing "make -C sdks/ios" from the repo root.

Fixes https://github.com/mono/mono/issues/13224
2019-02-28 21:47:21 +01:00
Mikhail Filippov f512a68edc [Mono.Debugger.Soft] Add new debugger tests and fix the Attach() test (#9091)
* Fixed the Attach() test which required a free port to attach.

* Added test for incorrect events behavior when VM is started with suspend

* Bump API snapshot submodule
2019-02-28 19:29:30 +01:00
Calvin Buckley a4eee02195 PPC JIT optimizations (System.Math instruction inlining) (#11964)
* [ppc] Optimize floating point performance in the JIT sqrt/sqrtf/abs

* [ppc] Integer Min/Max inlining wiht POWER5 isel instruction

Compresses a function call down to two instruction, for both signed
and unsigned, long and int. Needs to check for POWE5 though, and I
don't know the effects of this on ppc32. FP version using fsel is
also desirable, but not in the scope of this commit.

* [ppc] Check for POWER5 compatible CPU before using isel

* [ppc] Don't use long min/max inlining for ppc32

Other 64-bit operations are marked for ppc64 only.

* [ppc] also ifdef that out for ppc32 too

* [ppc] Rounding function optimizations
2019-02-28 09:31:12 -05:00
Johan Lorensson 3487962a82 Merge pull request #13210 from lateralusX/lateralusX/adjust-test-console-output
Update output from console-output test.
2019-02-28 06:40:33 -05:00
Johan Lorensson dd9ee189c6 Merge pull request #13212 from lateralusX/lateralusX/add-waitforkeypress-test-project
Add atexit-waitforkeypress handler in Visual Studio mono.sln test projects run args.
2019-02-28 05:06:38 -05:00
monojenkins ace38db535 [bcl] Update BCL Linked Size 2019-02-28 08:24:51 +01:00
Martin Baulig 3f43547cd6 [corlib]: Use Guid.NewGuid() implementation from CoreFx. (#13189)
* [corlib]: Use `Guid.NewGuid()` implementation from CoreFx.

The corefx implementation of `Guid.NewGuid()` uses the internal
`Interop.GetRandomBytes(byte*, int)`, which uses `RNGCryptoServiceProvider`
directly without using `CryptoConfig`.

* [csproj] Update project files

* Rename Guid.MonoTouch.cs -> CommonCrypto/Guid.cs.
2019-02-28 00:37:25 -05:00
Ludovic Henry 53b7b79f53 Initial support for Fuchsia (#13200)
* Initial support for Fuchsia

Compile like this:

if you have Zircon installed, with the prebuilts on "../zircon", use this to compile:

CC="`pwd`/../zircon/prebuilt/downloads/clang/bin/clang-9 -nostdlib -O2 -g -fdebug-prefix-map=/cvs/fuchsia/zircon=. -finline -fno-common -ffunction-sections -fdata-sections -no-canonical-prefixes -march=x86-64 -mcx16 --target=x86_64-fuchsia -fPIC -D_ALL_SOURCE=1 -DENABLE_DRIVER_TRACING=1 -fasynchronous-unwind-tables -fno-omit-frame-pointer  -std=c11 -I`pwd`/../zircon/build-x64-clang/sysroot/include/ -I`pwd`/../zircon/system/public" LDFLAGS="-L`pwd`/../zircon/build-x64-clang/sysroot/lib/ -L`pwd`/../zircon/build-x64-clang/sysroot/debug" ./configure --host=x86_64-google-fuchsia

* Use HOST_FUCHSIA rather than TARGET_FUCHSIA
2019-02-27 21:33:15 -05:00
Bernhard Urban 69cb9ad922 [interp] fix conflict of #13154 and #13177 (#13208)
See https://github.com/mono/mono/pull/13177#discussion_r259872514
2019-02-27 21:32:37 -05:00
Bernhard Urban 2030ebdc5e [interp] compute size of generic valuetype correctly (#13216)
[interp] compute size of generic valuetype correctly

Otherwise we smash the stack.


Contributes to https://github.com/xamarin/xamarin-macios/issues/5622
2019-02-27 18:25:40 -05:00
Calvin Buckley a3be248d3f [corlib] Simplify RuntimeInformation by getting OS name from the runtime (#13164)
We can get the the OS name similar to the architecture from the value that is used by the runtime for DllMaps.

Cached the values into static fields so we only need to do the runtime icall once.

Added all the existing OS names recognized by DllMap to RuntimeInformation.
This also allows us to mark some corlib/System tests that hang the runtime on AIX as non-working.
2019-02-27 23:21:34 +01:00
Miguel de Icaza fe92cea485 Use HOST_FUCHSIA rather than TARGET_FUCHSIA 2019-02-27 16:54:50 -05:00
Bernhard Urban a3dd8b3246 [lldb] fix helper for interpreter stacktraces (#13211)
Broke due to b6775765ed
2019-02-27 21:55:14 +01:00
Marek Safar 6f8ec5fdce Fixes build 2019-02-27 21:24:21 +01:00
Grant 448fd6ac62 Make BitOperations public (CoreCLR) (dotnet/coreclr#22864)
* Make BitOps public

* Update name to BitOperations

* Change namespace to System.Numerics

* Fix file name

* Alphabetical

Signed-off-by: dotnet-bot <[email protected]>
2019-02-27 21:24:21 +01:00
Maxim Lipnin 1ab0ffc964 [corlib] Update DriveInfo tests to use the newer RuntimeInformation APIs (#13205) 2019-02-27 19:23:19 +01:00
lateralusX 695743e3ab Add atexit-waitforkeypress handler in Visual Studio mono.sln test projects run args. 2019-02-27 17:45:57 +01:00
lateralusX ac906dd937 Update output from console-output test.
Current output from console-output test is just Error and Out (indicating)
the different console output streams. When seen in log files the error output
string can be misleading. Fix makes it clearer that the output is originating
from a test and not an “error”.
2019-02-27 17:19:30 +01:00
Zoltan Varga 8ca41f08a0 [jit] Fix the class of the stack entry for ldelema, it should be the class not its element class. (#13134)
Fixes https://github.com/mono/mono/issues/10101.
2019-02-27 16:31:54 +01:00
Martin Baulig 55a34261c9 [Mono.Security]: minor CryptoConvert changes to make it more linker-friendly. (#13204)
* Add new internal `CryptoConvert.TryImportCapiPrivateKeyBlob()` method that's using `RSAManaged` directly to make it more linker-friendly.

* Also add new internal `CryptoConvert.TryImportCapiPublicKeyBlob()`.

* Use it in `AssemblyName.IsPublicKeyValid`.
2019-02-27 12:56:06 +01:00
Zoltan Varga ce2259d009 [runtime] Default Interface method fixes. (#13154)
* [runtime] Inflate overridden methods properly during vtable construction when using default interface methods.

* [jit] Handle default interface methods in constrained calls, they need to box if the constrained type is a valuetype which doesn't override the default method.

* [runtime] Update Default Interface Methods tests from coreclr.

* [jit] Fix interp support.
2019-02-26 22:00:46 -05:00
Ankit Jain f7d053a0d6 nuget-hash-extractor: Improvements to reduce unnecessary diffs on update (#13197)
* [nuget-hash-extractor] Make the order for denied lists deterministic and

.. stable. We were not sorting the list of assemblies with the same
version, causing irrelevant changes in updates.

* Update denied assembly list to fix order

.. to be deterministic. Generated with the updated
nuget-hash-extractor.cs .

* [nuget-hash-extractor] Make the order of assemblies deterministic

The .nupkgs were being processed in arbitrary order, causing unncessary
diffs when updating them which required manual work to check and fix
them.
2019-02-27 00:41:11 +01:00
Martin Baulig 6a3b12b622 Revert "[Mono.Security]: minor CryptoConvert changes to make it more linker-friendly." (#13202)
This reverts commit ef7e64a5be.
2019-02-27 00:17:37 +01:00
Stephen Toub 48f65d5108 Special-case 1 module per assembly in Assembly.GetTypes/DefinedTypes (#22825)
It's very common for an assembly to have only one module, in which case we can avoid unnecessary allocations and copies in Assembly.GetTypes() and Assembly.DefinedTypes.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-27 00:03:26 +01:00
Dotnet-GitSync-Bot 2b4bff1956 Mirror changes from mono/coreclr (#13192)
This PR contains mirrored changes from mono/coreclr


**Please REBASE this PR when merging**

 cc @grant-d
2019-02-26 23:59:38 +01:00
Ludovic Henry a685cf26a4 [ci] Add new mode of execution for nunit tests on Android (#13098)
* [ci] Add new mode of execution for nunit tests on Android

This makes it possible to run the `nunit-lite-console.exe` on the host, while the tests still run on the device. This makes it transparent wherever the tests are running, giving us a seamless integration with the existing infrastructure based around nunit.

* [android] Fix System.Net.Http test suite

* [android] Fix System.ServiceModel.Web test suite

* [android] Fix Mono.Security test suite

* fixup! [ci] Add new mode of execution for nunit tests on Android

* [ci] Disable failing tests

* [csproj] Update project files
2019-02-26 22:08:01 +01:00
Miguel de Icaza a55e8496be Initial support for Fuchsia
Compile like this:

if you have Zircon installed, with the prebuilts on "../zircon", use this to compile:

CC="`pwd`/../zircon/prebuilt/downloads/clang/bin/clang-9 -nostdlib -O2 -g -fdebug-prefix-map=/cvs/fuchsia/zircon=. -finline -fno-common -ffunction-sections -fdata-sections -no-canonical-prefixes -march=x86-64 -mcx16 --target=x86_64-fuchsia -fPIC -D_ALL_SOURCE=1 -DENABLE_DRIVER_TRACING=1 -fasynchronous-unwind-tables -fno-omit-frame-pointer  -std=c11 -I`pwd`/../zircon/build-x64-clang/sysroot/include/ -I`pwd`/../zircon/system/public" LDFLAGS="-L`pwd`/../zircon/build-x64-clang/sysroot/lib/ -L`pwd`/../zircon/build-x64-clang/sysroot/debug" ./configure --host=x86_64-google-fuchsia
2019-02-26 15:55:41 -05:00
Zoltan Varga 5f5ef1efe5 [wasm] Disable chakra tests until its fixed. (#13199) 2019-02-26 21:41:46 +01:00
Vlad Brezae 88c560ad72 [interp] Avoid clearing the stack with each call (#13177)
* [interp] Move special case initialisation of frame->ip

* [interp] Properly init locals

When we have locals that need to be initialized.

* [interp] Load the entire enum value

When calling calling method on constrained type for enums with long storage.

* [interp] Avoid clearing the stack with each call

Reducing overhead for each call, this can give an overall performance improvement of 5%.
2019-02-26 12:01:29 -05:00
Alexander Kyte a0c6a15465 [runtime] Use FastCopy on multidimensional arrays (#13181) 2019-02-26 10:09:46 -05:00
Maxim Lipnin fc240aaa1c Consider unknown GB18030 characters as invalid to enforce use of replacement character instead of throwing SystemException. (#13188)
* Consider unknown GB18030 characters as invalid to enforce use of replacement character instead of throwing SystemException.

* Return negative result for unknown character instead of throwing SystemException in GB18030Source.FromUCS
2019-02-26 12:51:51 +01:00
Zoltan Varga 5225828263 [corlib] Add a RuntimeTypeHandle::GetCorElementType () icall, use it to remove a few other small icalls. 2019-02-26 12:51:14 +01:00
Alexander Köplinger 97f0a0f94c [ci] Use dl.internalx.com when building on private Jenkins
(cherry picked from commit 9d4aa950aa)
2019-02-26 11:25:45 +01:00
Martin Baulig ef7e64a5be [Mono.Security]: minor CryptoConvert changes to make it more linker-friendly.
* Add new internal `CryptoConvert.TryImportCapiPrivateKeyBlob()`
  method that's using `RSAManaged` directly to make it more
  linker-friendly.

* Use it in `AssemblyName.IsPublicKeyValid`.
2019-02-26 10:18:54 +01:00
Kenneth Pouncey 07287648b2 [wasm] Add browser test suite. (#13145)
* [wasm] Add browser test suite.

- Runs a series of tests against the HttpClientHandler and blob tests.

* Setup custom browser launcher to pass `--no-sandbox` to work on CI

* Remove auto client config that caused async errors on tests.
2019-02-26 10:07:21 +01:00
Marek Safar 7c975c18d8 AssemblyLoadContext from shared 2019-02-25 23:39:31 +01:00
Marek Safar 5ae98353a6 Move AssemblyLoadContext to shared partition (dotnet/coreclr#22685)
* Move AssemblyLoadContext to shared partition

* Move static initializer to DefaultAssemblyLoadContext

and remove stream copying from lock scope

Signed-off-by: dotnet-bot <[email protected]>
2019-02-25 23:39:31 +01:00
Martin Baulig 7f3a127b6d Remove unused (and broken) mono_btls_ssl_ctx_get_servername(). (#13184) 2019-02-25 20:15:17 +01:00
Bernhard Urban fc171a192a [aot] abort lookup early when a method isn't available in AOT image (#13138)
[aot] abort lookup early when a method isn't available in AOT image

Mixed mode depends on that.  Usually, compile_method of mini takes care
to request only existing methods from the AOT image, but in some cases,
e.g. from a trampoline, AOT runtime is quiered directly.

Contributes to https://github.com/xamarin/xamarin-macios/issues/5618
2019-02-25 10:56:15 -05:00
Jay Krell 2f3f58c7f1 [mkbundle] Fix mapping length (#13061)
* https://github.com/mono/mono/issues/11643 mkbundle problem - Illegal byte sequence

The size of the mapping is the maximum file offset to map.
See https://docs.microsoft.com/en-us/windows/desktop/Memory/creating-a-file-mapping-object.

When I tried it, I got a different error.

If in the debugger you simulate this fix, it gets further.

Here is a small program to exercise and see the behavior:

```
// include <windows.h>
// include <stdio.h>
// include <stdlib.h>
//
// int main()
// {
//  // Create a 128K file.
//
//  HANDLE file = CreateFile("1", GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
//  printf("createfile %p %d\n", file, GetLastError());
//
//  HANDLE map = CreateFileMapping(file, 0, PAGE_READWRITE, 0, 1 << 17, 0);
//  printf("createmap %p %d\n", map, GetLastError());
//
//  CloseHandle(map);
//  CloseHandle(file);
//  system("dir");
//
//  // Attempt to map the second 64K of the 128K file, with a 64K mapping.
//
//  file = CreateFile("1", GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
//  printf("createfile %p %d\n", file, GetLastError());
//
//  map = CreateFileMapping(file, 0, PAGE_READWRITE, 0, 1 << 16, 0);
//  printf("createmap %p %d\n", map, GetLastError());
//
//   // This fails.
//
//  PVOID view = MapViewOfFile(map, FILE_MAP_WRITE, 0, 1 << 16, 1 << 16);
//  printf("view %p %d\n", view, GetLastError());
//
//  CloseHandle(map);
//
//  // Use a 128K mapping instead. It works.
//
//  map = CreateFileMapping(file, 0, PAGE_READWRITE, 0, 1 << 17, 0);
//  printf("createmap %p %d\n", map, GetLastError());
//
//  view = MapViewOfFile(map, FILE_MAP_WRITE, 0, 1 << 16, 1 << 16);
//  printf("view %p %d\n", view, GetLastError());
// }
```

Here is debugging mono and simulating the fix in the debugger (I did not build or test
the fix):

```

\bin\amd64\cdb C:\Users\jaykrell\Downloads\output\output.exe

0:000> bm kernel*!*createfilemap*
0:000> g

Breakpoint 2 hit
KERNELBASE!CreateFileMappingW:
00007ffd`0a449de0 4883ec48        sub     rsp,48h
0:000> dv
                  hFile = 0x00000000`00000200
lpFileMappingAttributes = 0x00000000`00000000
              flProtect = 2
      dwMaximumSizeHigh = 0
       dwMaximumSizeLow = 0x477000
                 lpName = 0x00000000`00000000 ""

0:000> bm kern*!*mapviewoffile*
0:000> g
Breakpoint 38 hit
KERNEL32!MapViewOfFileStub:
00007ffd`0b09bfa0 48ff2591c10500  jmp     qword ptr [KERNEL32!_imp_MapViewOfFile (00007ffd`0b0f8138)] ds:00007ffd`0b0f8138={KERNELBASE!MapViewOfFile (00007ffd`0a465ad0)}
0:000> dv
  hFileMappingObject = 0x00000000`00000204
     dwDesiredAccess = 4
    dwFileOffsetHigh = 0
     dwFileOffsetLow = 0x30000
dwNumberOfBytesToMap = 0x477000
0:000> gu
0:000> r rax
rax=0000000000000000
0:000> !gle
LastErrorValue: (Win32) 0x5 (5) - Access is denied.
LastStatusValue: (NTSTATUS) 0xc000001f - {Invalid Mapping}  An attempt was made to create a view for a section which is bigger than the section.

0:000> .restart
0:000> bm kernel*!*createfilemap*
0:000> g
0:000> dv
                  hFile = 0x00000000`00000220
lpFileMappingAttributes = 0x00000000`00000000
              flProtect = 2
      dwMaximumSizeHigh = 0
       dwMaximumSizeLow = 0x477000
                 lpName = 0x00000000`00000000 ""
0:000> ?? dwMaximumSizeLow += 0x30000
unsigned long 0x4a7000
0:000> bc *
0:000> g
Corlib not in sync with this runtime: The runtime did not find the mscorlib.dll it expected. Expected interface version CA4932AE-2294-4ECD-B863-BF98FDD84F33 but found 0CC970F6-6F25-4218-9427-3E4C3DC8DE33. Check that your runtime and class libraries are matching.
Loaded from: mscorlib.dll
Download a newer corlib or a newer runtime at http://www.mono-project.com/download.

```

* Restore useful part of comment.

* Restore dead code.

* Add to comment the other possibility that is being countered.

* Additional explanation.
2019-02-25 09:48:04 -05:00
Johan Lorensson e6d259b82c Fix multiple issues with response file option on Windows. (#13132)
* Fix multiple issues with --response file option on Windows.

* If file is UTF8 encoded and include BOM mark, implementation failed to
detect and remove BOM mark causing errors. Fix check for BOM mark and if
found, remove it before passed to parsing. NOTE, current implementation
only supports UTF8 (and ASCII) content in response file and won't detect
or handle any other codepages.

* Since the content in --response file should mimic what should have been
passed on command line, we should apply same parsing rules on Windows as done
by the shell when running the arguments on the command line. Current
implementation uses its own parsing that is not the same as used by the Windows
shell, meaning that arguments can't be identical in response file compared to
what's passed on command line. This commit fix parsing of the command
line in the response file so its first parsed by the shell before added
to internal argc, argv parameters (similar as done when passed to main function).

* Add support to handle new lines in response file on Windows.
2019-02-25 09:42:44 -05:00
Radek Doulik 4a96c5e715 [aot] Resolve profile against compiled assembly (#13148)
[aot] Resolve profile against compiled assembly

When trying to use AOT profile in XA for assembly AOT compilation, the
methods from the profile were not compiled.

Context: https://github.com/xamarin/xamarin-android/issues/2504

The problem was, the profile data were not resolved, as there was no
assembly loaded in the domain.

With this fix, the compiled assembly is used to resolve the profile as
well.
2019-02-25 08:35:48 -05:00
Marek Safar ecef8d334a [System.Private.CoreLib] Implement more APIs 2019-02-25 13:51:30 +01:00
monojenkins 8a417e9cb6 Bump API snapshot submodule 2019-02-25 13:30:32 +01:00
Martin Baulig aee90aca7c Make System.dll internals visible to Mono.Android. 2019-02-25 13:30:32 +01:00
Zoltan Varga c94af71bf0 [corlib] Hardcode IsRunningOnWindows as false on WASM too. (#13161) 2019-02-25 03:18:28 -05:00
Kenneth Pouncey fdbebe278e Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-25 04:54:45 +01:00
Zoltan Varga 6644136745 [wasm] Update to emscripten 1.38.28. (#13160)
* [wasm] Update to emscripten 1.38.28.

The emscripten patch is no longer needed.

* [wasm] Disable optimizations in SHA1Transform (), the normal version seems to cause stack overflows in binaryen's asm2wasm tool.
2019-02-24 22:50:31 -05:00
Zoltan Varga f52f874aae [wasm] Small fixes. (#13166)
* [wasm] Disable an unused icall which has an invalid signature under wasm.

* [aot] Make the dedup pass less verbose.
2019-02-24 22:42:55 -05:00
Eric StJohn b936c53101 Make System.Runtime.CompilerServices.Unsafe inbox (dotnet/corefx#35526)
* Make System.Runtime.CompilerServices.Unsafe inbox

Fix a couple places where we wanted to use it from other inbox assemblies but couldn't.

Unsafe remains as a package and newer versions of Unsafe will replace the inbox Version,
permitting us to add API over time.

* Update Rune tests to use TryEncodeToUtf8Bytes directly

* Add temporary suppression to package tests

Signed-off-by: dotnet-bot <[email protected]>
2019-02-23 08:52:41 +01:00
Ankit Jain 6df26e8287 [nuget] Add new versions of System.Net.Http
.. to the list of denied assemblies. Added `4.3.4`.

Prompted by issue #12603 .
2019-02-23 08:51:03 +01:00
Ankit Jain ae240f1f8e [nuget] Add new versions of System.Text.Encoding.CodePages ..
.. to the list of denied assemblies. Added:

- `4.5.0`
- `4.5.1`

Fixes issue #12603 .
2019-02-23 08:51:03 +01:00
Jan Kotas 6df88479c8 Change Environment.Version to return product version (dotnet/coreclr#22664)
* Change Environment.Version to return product version

- Contributes to https://github.com/dotnet/corefx/issues/31099
- Use AssemblyInformationalVersion attribute as fallback

* Add sanity test for Environment.Version

* Disable CodeDom tests

* Fix test assembly name

Signed-off-by: dotnet-bot <[email protected]>
2019-02-23 08:49:36 +01:00
Stephen Toub b0d3ead369 Ignore EINVAL/EBADF errors from FTruncate in FileStream.Init (#22788)
They indicate we're working with a special file, where failure to truncate is not a fatal condition.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-22 22:24:37 +01:00
Vincent Dondain 0525583d1e [System] Bump SocketTest.TestSelect1 socket timeout to 1ms (#13152)
- Previous test with 100 micro second timeout would fail on iOS device when running **all the socket tests** about 3 times out of 5.
- With a 1 millisecond timeout, it didn't fail the 10 times I tried locally, hopefully this is enough to fix the flakiness.
- Fixes #8360: [System.Net.Sockets] flakey failures of SocketTest.TestSelect1 on Darwin systems
  (https://github.com/mono/mono/issues/8360)
- Also partial fix for maccore issue https://github.com/xamarin/maccore/issues/1069
2019-02-22 21:28:06 +01:00
Kenneth Pouncey 80f8aa27b1 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays
# Conflicts:
#	sdks/wasm/Makefile
2019-02-22 14:24:14 +01:00
Ankit Jain a4fada3900 [fsharp] Fix a type inference error introduced by recent changes (#13109)
```
@/external/bockbuild/builds/fsharp-fsharp-6624925/src/scripts/fssrgen.fsx(334,28): error FS0041: A unique overload for method 'GetFileNameWithoutExtension' could not be determined based on type information prior to this program point.
A type annotation may be needed. Candidates: System.IO.Path.GetFileNameWithoutExtension(path: System.ReadOnlySpan<char>) : System.ReadOnlySpan<char>, System.IO.Path.GetFileNameWithoutExtension(path: string) : string
[@/external/bockbuild/builds/fsharp-fsharp-6624925/src/fsharp/FSharp.Build-proto/FSharp.Build-proto.fsproj]
```
2019-02-22 08:00:41 -05:00
Bernhard Urban 3be2390665 [aot] add wrappers to "slim" mscorlib (i.e. --aot=interp) (#13137)
* [aot] add gc wrappers in interp scenario

* [aot] add icall wrappers in interp scenario
2019-02-22 07:59:53 -05:00
Zoltan Varga 55c998d282 [aot] Only emit the static interp trampolines/wrappers into the mscorlib AOT image. (#13117) 2019-02-22 07:58:57 -05:00
Ludovic Henry 49b6628370 [aot] use unbox arbitrary trampolines for "slim" mscorlib (#13139)
We need the recently introduced "unbox arbitrary" trampolines in one more
scenario: non-mscorlib AOT code calls a method from mscorlib with
interpreter. Before we just relied on the amodule not being available,
but mscorlib amodule is always present due to wrappers, trampolines,
etc.
2019-02-22 07:57:16 -05:00
Vlad Brezae b6775765ed [interp] Cleanup code a little (#13092)
* [interp] Cleanup code a little

* [interp] Rename rtm to imethod
2019-02-22 07:55:37 -05:00
Thays Grazia 1e1e0b6b01 [wasm] [debugger] Add test suite. (#13093)
* [wasm] [debugger] Add test suite.

* [wasm] [debugger] Add test suite.

* [wasm] [debugger] Add test suite.

* Changing what Larry suggested and removing some -debug that is not used.

* Adding the DebuggingTestSuite.

* indentation

* Update run-jenkins.sh
2019-02-22 07:52:59 -05:00
Zoltan Varga 50ce9ed8e5 [netcore] Implement AppContext. 2019-02-22 10:19:37 +01:00
monojenkins 66e88b1e6b [bcl] Update BCL Linked Size 2019-02-22 10:03:28 +01:00
Bernhard Urban af46af33a1 [jit/cprop] insert dummy insn if first insn of basic block got replaced (#13127)
[jit/cprop] insert dummy insn if first insn of basic block got replaced

Fixes https://github.com/mono/mono/issues/13056 & https://github.com/mono/mono/issues/13057
2019-02-21 21:05:34 -05:00
Bernhard Urban 8891a4b778 [aot] use unbox arbitrary trampolines for "slim" mscorlib
We need the recently introduced "unbox arbitrary" trampolines in one more
scenario: non-mscorlib AOT code calls a method from mscorlib with
interpreter. Before we just relied on the amodule not being available,
but mscorlib amodule is always present due to wrappers, trampolines,
etc.
2019-02-21 23:28:41 +01:00
Zoltan Varga 2124448a37 [runtime] Move mono_get_context_capture_method () from security-manager.c to object.c. (#13071) 2019-02-21 16:26:05 -05:00
Maxim Lipnin 506406df06 Try to extract valid drive name from DriveInfo ctor string argument (#13105)
It's possible to pass any string as an argument to DriveInfo ctor (e.g.  `new DriveInfo(Path.GetTempPath())`). Mono throws ArgumentException if there is no exactly the same drive name in the list of available drives.

I tried to handle this case by extracting any valid drive name from the array of available drives sorted by path in descending order.

Fixes https://github.com/mono/mono/issues/12157
2019-02-21 21:57:55 +01:00
Marek Safar 020ce70e30 [System.Private.CoreLib] Implement more APIs 2019-02-21 21:34:18 +01:00
Martin Baulig 7277e3bb5e SslStream improvements and tests
* Add server-side Server-Name-Indication (SNI) support (both AppleTls and BTLS).

* Support the new `SslServerAuthenticationOptions.ServerCertificateSelectionCallback`.

* Server certificate selection is now compatible with CoreFx behavior; first
  checking the new `ServerCertSelectionDelegate` then `LocalCertSelectionCallback`
  and finally using an explicitly provided certificate.

* Misc exception checks and fixes to make behavior consistent with CoreFx;
  any exception thrown by reading / writing the underlying stream will now be
  propagated verbatim (and not wrapped in an `AuthenticationException`);
  exceptions thrown by the handshake / TLS stack itself will still be wrapped.

* Added `System.Net.Security` xUnit tests from CoreFx.

* Misc test cleanups; moved certificate test files from `System.Net.Http` into
  `System` and embed them in the test assembly as resources, adjusting
  `test-helpers/Configuration.Certificates.cs` accordingly.
2019-02-21 20:43:25 +01:00
Zoltan Varga aa04713723 [llvmonly] Do null checks on interp transitions for virtual->non virtual calls. (#13118)
Fixes https://github.com/mono/mono/issues/12998.
2019-02-21 12:24:14 -05:00
Alexander Köplinger b740313aa5 [sdks] Make sure to run only one build per type per node
They could conflict while provisioning android toolchains etc. otherwise.
2019-02-21 17:33:41 +01:00
Ankit Jain bda914c9b5 [bockbuild] Bump to master HEAD to get new fixes (#13108) 2019-02-21 17:19:27 +01:00
Zoltan Varga 576b1a0827 [llvm] Mark the branch in OP_GC_SAFE_POINT as taken. (#13114) 2019-02-21 10:08:04 -05:00
Kenneth Pouncey 7038d1915a Small cleanup 2019-02-21 14:05:08 +01:00
Kenneth Pouncey 49b92c95d0 Modify public interface CopyTo and CopyFrom to use lightweight Span<U>.
- Modifications in response to review comments.
2019-02-21 14:03:24 +01:00
Johan Lorensson 6f786bc465 Disable Mono.CSharp on Windows x64 full AOT test. (#13124)
Not part (and should not be) part of the winaot profile and therefore not testable (even though they pass when manually AOT:ing the assembly).
2019-02-21 13:29:34 +01:00
Vlad Brezae ff84ee290e [runtime] Remove dead code (#13089)
[runtime] Remove dead code

Interface method calls on constrained types are resolved in get_method_constrained now (apparently since https://github.com/mono/mono/commit/3259e04ace67552fc8d63a8f1ddbb830e526f05f)
2019-02-21 06:55:48 -05:00
Tanner Gooding af1034a99c Enable the HWIntrinsic extension methods and remove the instance implementations (#22705)
* Removing various S.R.I.Vector instance method APIs, since they should now be exposed as extension methods

* Updating the JIT to recognize the S.R.I.Vector extension methods.

* Updating various S.R.I.Vector test templates

* Regenerating the S.R.I tests that are created from a template.

* Fixing the numArgs for Base_Vector256_GetLower

* Fixing the handling for `Base_VectorXXX_As` to normalize the struct type.

* Adding the Base_Vector128_As intrinsics back for arm64

Signed-off-by: dotnet-bot <[email protected]>
2019-02-21 12:26:09 +01:00
Nikolay Sivov ffd601eed4 Fix some compiler warnings (#13044)
Fix some compiler warnings

Compiled with gcc 8.2.0/x86_64-linux-gnu.
2019-02-21 06:05:47 -05:00
Vlad Brezae 809e40435f [tests] Fix function signature (#13090)
[tests] Fix function signature

To match pinvoke signature from pinvoke-2 test.
2019-02-21 04:15:53 -05:00
Johan Lorensson 3622703cbe Enable all CI test suites for Windows x64 full AOT. (#13102) 2019-02-21 10:04:20 +01:00
Ben Adams bcdc345b44 Reduce struct copy by 1 in ValueTask.GetAwaiter (dotnet/coreclr#22738)
* Reduce struct copy by 1 in ValueTask.GetAwaiter

* Bit more explicit

Signed-off-by: dotnet-bot <[email protected]>
2019-02-21 10:02:14 +01:00
Filip Navara 5d36e4b2a7 Move Thread to shared CoreLib (dotnet/corefx#35462)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-21 10:00:54 +01:00
Zoltan Varga b4943dec39 [jit] Fix the loaded llvm build. (#13110) 2019-02-21 03:45:36 -05:00
Zoltan Varga d48b84d67f [llvm] Fix a 'incoming phi sreg1' llvm failure which happens with valuetypes+phi nodes. (#13077)
[llvm] Fix a 'incoming phi sreg1' llvm failure which happens with valuetypes+phi nodes.

Fixes https://github.com/mono/mono/issues/12988.
2019-02-21 03:35:54 -05:00
Aleksey Kliger (λgeek) 72512cfbcb [loader] Fix off by 1 (netstandard is a framework facade) (#13111)
[loader] Fix off by 1 (netstandard is a framework facade)

Before 5e0d39a8a1, there used to be a handwritten binary search that traveersed `framework_assemblies` to determine if a given assembly was a framework assembly or not.  The binary search used `last = G_N_ELEMENTS (framework_assemblies) - 1` as the initial condition, but it used an inclusive `first <= last` as the loop count.

After we switched to a hashtable, we used the same final value initialize `assembly_remapping_table`.

We didn't notice because `mscorlib` used to be the last assembly in the table and `mscorlib` already has a ton of special handling in the loader.  But `netstandard` is not special.  So we added it to the table, but it still doesn't get special handling.

This should fix instances where code references netstandard 2.0.0.0, but we give it netstandard 2.1.0.0

https://github.com/mono/mono/blob/f8094319132d2d40f37e8cac6058e783b5648260/mono/metadata/assembly.c#L345
2019-02-21 01:45:50 -05:00
Stephen Toub f809431913 Use ThrowHelper in ManualResetValueTaskSourceCore (dotnet/coreclr#22714)
Just move the helper being used to ThrowHelper.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 22:47:35 +01:00
Stephen Toub a5e27b6316 Fix bug introduced during cleanup in JapaneseLunisolarCalendar (#22717)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 20:24:29 +01:00
Ben Adams bce27a80de Allow Task.WaitAny completion to run synchronously (dotnet/coreclr#21245)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 20:24:29 +01:00
Johan Lorensson 795dc5ebd2 Remaining fixes needed to pass rest of CI test suites for windows x64 full AOT. (#13084)
* Fix for runtime mcs-compileall test on Windows x64 full AOT.

Test picked up full AOT:ed libraries as well as managed libraries failing
the test. Full AOT:ed shared libraries on Windows has .dll.dll prefix and
full AOT:ed executables on Windows has .exe.dll prefix.

Fix makes sure to filter out any files ending with dll.dll or exe.dll.

* Fix build errors in System.Web.Services test under winaot profile.

* Fix errors in System.Core test under winaot profile.

* Fix build error in linker tests on Windows under winaot profile.

Build fails since profile build mscorlib is used as well as default
triggering build error. Fix is to build linker tests using -nostdlib flag.
2019-02-20 14:17:10 -05:00
Johan Lorensson 3bcebfb0a0 Don't install jay as part of make install. (#13086)
Should not be part of the package and cause issues on Windows 32-bit
cygwin build since it's not using makefile generated by autotools. When
make install is run it will build jay one more time, but picking up
cygwin default gcc compiler instead of the one used in configure step, mingw.
That cause link errors since the object files are not rebuild, only relinked
with different linker, causing errors.
2019-02-20 14:01:03 -05:00
Alexander Köplinger 78ef5a9722 [ci] Prefer gmake over make for SDKs build (#13091)
Apple's make doesn't support the --output-sync option and Homebrew's make is installed as gmake.

Also fixed a few places in the repo where we directly invoked make instead of $(MAKE).
2019-02-20 19:46:54 +01:00
Marek Safar 951803d082 [System.Private.CoreLib] Implement more APIs 2019-02-20 17:55:17 +01:00
Stephen Toub 5ec1def012 Fix race condition in ManualResetValueTaskSourceCore (dotnet/coreclr#22711)
* Fix race condition in ManualResetValueTaskSourceCore

ManualResetValueTaskSourceCore.GetStatus is used from ValueTaskAwaiter.IsCompleted.  If GetStatus returns Success too early, then IsCompleted will also return true too early, which will result in GetResult being called too early.  This doesn't happen today when an MRVTSC is used sequentially.  But if an instance is pooled by the object its stored on getting put back into a pool as part of a call to the wrapper's GetResult, then we can end up in the following situation:
- Thread 1 starts an await on an instance containing an MRVTSC.  It calls IsCompleted.
- Thread 2 starts to complete that instance, getting as far as calling SignalCompletion and setting _completed to true but not yet setting _continuation.
- Thread 1 sees _completed == true and returns true from IsCompleted.  It calls GetResult, and the wrapper extracts the result from the instance, resets it, and puts it back into the pool.
- Thread 3 takes the object out of the pool and starts using it.
- Thread 2 continues SignalCompletion on that instance, and sets _continuation to the sentinel.
- Now Thread 3's instance's _continuation is the sentinel when it should be null.  If it calls SignalCompletion, it'll erroneously find that _continuation is not null and will queue _continuation/_continuationState for execution, resulting in the sentinel getting executed.  If it calls OnCompleted, it'll find that the _continuation is not null, and will queue the supplied continuation/state to execute immediately even though the operation may not yet actually be done.

The fix is simply to check not just _completed but also _continuation.  The operation is considered pending if either _completed is false, meaning SignalCompletion has not yet been called, or if _continuation is still null, meaning it's neither been set to the supplied delegate nor to the sentinel.  We can't just rely on _completed for the above outlined reasons, and we can't just rely on _continuation because it can be non-null if OnCompleted was called to hook up a callback (if we only cared about the await pattern, then we could just check _continuation and wouldn't need _completed, but we also need to support non-await access).

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 13:02:45 +01:00
Alexander Köplinger 3ac43f72bb Update sdks-archive.groovy android packages 2019-02-20 11:46:36 +01:00
Egor Bogatov 3c41d74f1e NS2.1: System.Security.Cryptography changes (#13022)
* NS21: X509Store, rsa.cs

* More NS2.1 changes

* remove X509Stubs.cs

* Add corert/CancellationTokenRegistration.cs

* Implement Socket.ReceiveAsync

* Add X509Certificates stubs

* bump corefx and corert

* bump corefx

* remove corefx/tmp

* Bump API snapshot submodule

* [csproj] Update project files
2019-02-20 11:43:26 +01:00
monojenkins fceb9471e2 [bcl] Update BCL Linked Size 2019-02-20 09:16:55 +01:00
Jan Kotas ad4c22c4f4 Use out arguments in UmAlQuraCalendar (dotnet/coreclr#22704)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 09:13:30 +01:00
Kenneth Pouncey 16f1845a19 Fix spacing 2019-02-20 07:30:24 +01:00
Kenneth Pouncey 2e4713cb39 Fix spelling 2019-02-20 07:29:49 +01:00
Kenneth Pouncey d60440869c Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-20 06:40:15 +01:00
Ludovic Henry 7f017427ea Update CODEOWNERS 2019-02-19 19:41:45 -05:00
Radek Doulik 30799ff97f [profiler] Do not print that many new lines (#13060)
The `mono_profiler_printf` already adds `\n` char, so we don't need to
add them in most cases.

Before the fix the output of aot profiler with verbose enabled looked
like:

    02-19 10:50:02.877 22795 22815 I mono-prof: System.OutOfMemoryException:.ctor (string) 2
    02-19 10:50:02.877 22795 22815 I mono-prof:
    02-19 10:50:02.877 22795 22815 I mono-prof: System.SystemException:.ctor (string) 4
    02-19 10:50:02.877 22795 22815 I mono-prof:
    02-19 10:50:02.877 22795 22815 I mono-prof: System.Exception:.ctor (string) 6
    02-19 10:50:02.877 22795 22815 I mono-prof:
    02-19 10:50:02.877 22795 22815 I mono-prof: System.Exception:.cctor () 7
    02-19 10:50:02.877 22795 22815 I mono-prof:
    ...

The `usage ()`'s output should now look similar to other profilers
usage output.
2019-02-19 18:27:04 -05:00
Stephen Toub aff251e11c Move EventRegistrationToken to shared (dotnet/coreclr#22565)
* Move EventRegistrationToken to shared

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-20 00:18:55 +01:00
Stephen Toub e5f7fa3e67 Use RunContinuationsAsynchronously in SemaphoreSlim.WaitAsync (#22686)
SemaphoreSlim.Release shouldn't invoke arbitrary continuations as part of its invocation, so when it dequeues a task waiter and goes to complete it, rather than just calling TrySetResult, it queues the task to the thread pool to have TrySetResult invoked there.  Now that we have RunContinuationsAsynchronously, though, we can just use that functionality instead.  This has two main benefits:
1. We avoid queueing a work item entirely if there are no continuations from the task.  This might happen, for example, if the semaphore is released so quickly after waiting on it that the WaitAsync caller hasn't yet hooked up a continuation, in which case the await on the WaitAsync task will just see IsCompleted as true and continue running.
2. We avoid queueing a work item when the task represents a synchronous Wait, which happens if there's already a pending WaitAsync when Wait goes to block.  The main benefit here is avoiding potential thread pool starvation, if threads in the pool are blocked in such Waits, and previously another thread pool thread would have been needed to run the queued work item to complete the synchronous Wait.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-19 23:45:33 +01:00
Hugh Bellamy dc32ce591e Cleanup Calendars code (dotnet/coreclr#22582)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-19 23:45:33 +01:00
Martin Baulig 23762efca5 Add temporary workaround for internal StreamContent constructor. 2019-02-19 23:19:07 +01:00
Maxim Lipnin c890be00c9 use for loop to access item values and avoid InvalidCastException which occurs because VirtualDirectoryMappingCollection enumerator returns key and it's not expected 2019-02-19 21:08:02 +01:00
Fei Peng 1f33f3923a Optimize Vector128/256<T>.Get/WithElement (dotnet/coreclr#22353)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-19 17:08:46 +01:00
Johan Lorensson 187711df20 Enable runtime + corlib tests on CI for Windows x64 full AOT. (#13059) 2019-02-19 09:37:43 -05:00
Vlad Brezae c21c2df0af [interp] Kill stinarg opcodes (#13038)
* [interp] Extract some duplicated code

* [interp] Kill stinarg opcodes

Before we were reallocating the arguments in the current frame and had a stinarg opcode for copying each argument there. Access the arguments directly from the parent frame, to reduce call overhead. This can give up to 5-10% general speedup.
2019-02-19 08:40:00 -05:00
roozbehid af0bdab76d add missing typeforwardes in facades (#12694)
* add missing typeforwardes

* Bump API snapshot submodule
2019-02-19 13:38:17 +01:00
Zoltan Varga 9f9067094f [netcore] Fix GCHandles, the lowest bit is used by the GCHandle class to store information. 2019-02-19 10:51:51 +01:00
Marek Safar 2e88b48fde [mcs] Remove doc about CAS security 2019-02-19 10:14:48 +01:00
Zoltan Varga b8b2469380 [jit] Add a few more unsafe intrinsics. (#12971) 2019-02-19 02:27:40 -05:00
Katelyn Gadd 66092e0571 Update roslyn-binaries submodule to point to latest master revision (#12833)
This updates our roslyn submodule so that the new csc-dim is available.
2019-02-18 22:54:54 +01:00
Alexander Köplinger 1c26f21c0d Bump linker submodule to latest master (#13031)
* Bump linker submodule to latest master

* [csproj] Update project files
2019-02-18 14:02:34 +01:00
Phil Jaenke 8c185ed423 Remove leading . from script invocation (#13046)
The leading `.` in the script invocation causes the tests to fail on multiple platforms by causing the required argument to not be passed correctly resulting in bad output. Removal of the leading `.` ensures correct operation on all platforms.
2019-02-18 12:45:25 +01:00
Alexander Köplinger 602bdea385 Set executable bit for all .sh files in repo 2019-02-18 12:39:57 +01:00
bwadswor fe7c3d43e5 Correct access permissions to include "user execute" for run-msbuild.sh. (#13042)
Correct access permissions for run-msbuild.sh.  Adding "user execute" seems to fix the following build error.  With this change I'm able to build on windows in Cygwin.  without, I see the below error:

```
$ make -j4
(CDPATH="${ZSH_VERSION+.}:" && cd . && /bin/sh /cygdrive/c/mono/mono/missing autoheader)
rm -f stamp-h1
touch config.h.in
cd . && /bin/sh ./config.status config.h
config.status: creating config.h
config.status: config.h is unchanged
Git submodules updated successfully
make  all-recursive
make[1]: Entering directory '/cygdrive/c/mono/mono'
Making all in msvc
make[2]: Entering directory '/cygdrive/c/mono/mono/msvc'
Building Mono runtime using Visual Studio.
../msvc/run-msbuild.sh "build" "i686"
**/bin/sh: ../msvc/run-msbuild.sh: Permission denied**
make[2]: *** [Makefile:614: all-local] Error 126
make[2]: Leaving directory '/cygdrive/c/mono/mono/msvc'
make[1]: *** [Makefile:583: all-recursive] Error 1
make[1]: Leaving directory '/cygdrive/c/mono/mono'
make: *** [Makefile:513: all] Error 2
```
2019-02-18 12:34:29 +01:00
Zoltan Varga 77644b833e [netcore] EH work (#13041)
* [netcore] Switch to Debugger class from corlib.

* [netcore] Implement exception stack trace support.

* Address review comments.

* [netcore] Create a netcore specific version of Exception based on the refsource version.
2019-02-18 10:20:45 +01:00
Martin Baulig 099e003240 Add types supporting C# 8.0 Ranges. (#12841)
* Add types for C# 8.0 Ranges.

* Add workaround from @lewurm to fix the native crash.

* Fix compiler error test.

* [interp] guard span get_item intrinsic regarding its signature

* Cleanup sources and remove duplicates; thanks Egor!

* Bump API snapshot submodule

* [csproj] Update project files
2019-02-18 09:55:45 +01:00
Marek Safar ad62ab26b7 Merge pull request #13040 from marek-safar/build-fixes
[System.Private.CoreLib] Implement more APIs
2019-02-17 11:03:18 +01:00
Jan Kotas 003a626bba Avoid pulling in Lazy<T> during startup (dotnet/coreclr#22659)
Environment constructor runs on every startup path. Remove dependency on Lazy<T> from it.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-17 11:02:36 +01:00
Thays Grazia 194b82b8b0 If getter is not implemented in a property we don't want to show this property, in Vs the behaviour is the same. (#13033)
Fixes #12964
2019-02-16 11:48:00 -02:00
Marek Safar f0ca41c781 [System.Private.CoreLib] Implement more APIs 2019-02-16 00:47:18 +01:00
Tanner Gooding a12209bf52 Updating some local functions to be 'static' (captureless). (#22635)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-16 00:20:34 +01:00
Alexander Kyte 12b3dbcc38 [crash] Move dump_memory_around_ip after the native crash (#13021)
If someone jumps to a bogus address for some reason, this will
double-fault. On OSX, a double fault is often a hang.
2019-02-15 18:14:03 -05:00
Vlad Brezae b3839e4434 [interp] Fix unaligned crashes on arm (#12985)
* [interp] Fix unaligned access crashes on arm

strd instruction fails if the memory address is not word aligned.

Fixes corlib-xunit suite on arm.

* [interp] Fix warning
2019-02-16 00:06:00 +02:00
Alexander Köplinger d224a047e0 Revert "[Facades] Remove System.Drawing.Primitives from xammac_net_4_5_SUBDIRS"
This reverts commit 9c1fd50666.

This is wrong, net_4_x_SUBDIRS only includes common_deps_SUBDIRS, not common_SUBDIRS.
2019-02-15 20:39:33 +01:00
Ludovic Henry 42f7bff05b [ci] Fix Bitcode{+Interpter} on AArch64 (#13016) 2019-02-15 13:38:20 -05:00
Kenneth Pouncey ccfa653b48 [wasm][CI] Reactivate Chakra tests in CI (#13026)
- Chakra install fails: https://github.com/Microsoft/ChakraCore/issues/5945
2019-02-15 12:12:37 +01:00
Alexander Köplinger 9c1fd50666 [Facades] Remove System.Drawing.Primitives from xammac_net_4_5_SUBDIRS
It's already included in the common_SUBDIRS and confuses a build safeguard in xamarin-macios.
2019-02-15 12:03:40 +01:00
Marek Safar 34c3055a7c Move Interlocked 2019-02-15 09:25:26 +01:00
Tanner Gooding 884b4c2473 Fixing the number formatting code to only recognize 'R' for double/float. (#22613)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-15 09:25:26 +01:00
Marek Safar f2c8664ac1 Move Reflection.Emit Tokens to shared partition (dotnet/coreclr#22602)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-15 09:25:26 +01:00
monojenkins 4ee073da2a [bcl] Update BCL Linked Size 2019-02-15 08:34:51 +01:00
Grant 7e52c1973e Missed optimization from #22497
Signed-off-by: dotnet-bot <[email protected]>
2019-02-15 08:33:24 +01:00
Larry Ewing 7f0eaf39ca Add some blazor binaries to bcl-size-diff 2019-02-14 23:57:30 +01:00
Grant d91a227cba Consolidate implementation of Rotate and PopCount (dotnet/coreclr#22584)
* Perf: BitOps.LeadingZeroCount

* Remove redundant MSIL cast, conv.u8

* Use local functions for SoftwareFallback

* Target BIT32/64

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 23:00:36 +01:00
Marek Safar 8294fc0588 Remove local FrameworkEventSource 2019-02-14 22:47:06 +01:00
Marek Safar dbac2e4ffc Move FrameworkEventSource to shared partition (dotnet/coreclr#22507)
* Move FrameworkEventSource to shared partition

and remove unused code

* Remove more unused code

* Remove CA8001 suppress message

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:47:06 +01:00
Levi Broderick 776e2a84c3 Add Rune creation API from UTF-16 surrogate pair (dotnet/coreclr#22590)
Also brings in some perf improvements to existing char and UnicodeUtility APIs

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:47:06 +01:00
Egor Bogatov cf69b47259 NS2.1: System.IO, System.Reflection.Emit, etc (#12854)
* System.IO, System.Data

* lots of small ns21 improvements

* More changes (System.Reflection.Emit)

* Add IEquatable to S.R.Emit types

* bump corefx

* fix unix build

* more NS21 changes

* more changes

* bump corefx

* Fix failing tests (Sockets)

* bump corefx

* tmp workaround

* move DispatchProxyGenerator to net_4_x

* Bump API snapshot submodule

* [csproj] Update project files
2019-02-14 22:40:58 +01:00
Grant 572d9928c0 Perf: Consolidate implementation of LeadingZeroCount (dotnet/coreclr#22497)
* Perf: BitOps.LeadingZeroCount

* CR fix

* CR fixes

* Optimization

* Revert

* Confirmed fix

* Simplify

* Return int

* Fixes

* Simplify

* CR fixes

* CR fixes

* Fix unit failure on Linux-musl x64 Debug

* CR fixes

* CR fixes

* Cleanup

Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:38:32 +01:00
Fei Peng 938477a7de Remove unnecessary ThrowIfUnsupportedType calls and definitions
Signed-off-by: dotnet-bot <[email protected]>
2019-02-14 22:38:32 +01:00
Ludovic Henry 1be2bbce16 [ci] Enable working Bitcode{+Interpreter} test suites (#12997) 2019-02-14 14:47:05 -05:00
Martin Baulig 5c754423f2 Pass X509Certificate2 to the certificate validator.
This makes us consistent with corefx; see also
https://github.com/dotnet/corefx/pull/35306.

Using `X509Certificate` has become a problem because the
`HttpClientHandler.ServerCertificateCustomValidationCallback`
callback takes an `X509Certificate2` parameter.
2019-02-14 18:27:13 +01:00
Maxim Lipnin 347af5d61f Bump ikdasm 2019-02-14 18:09:49 +01:00
Rolf Bjarne Kvinge 4fec79cc6a [tests] Add the BitcodeNotSupported category to tests exercising non-bitcode-compatible API. (#13007)
* [tests] Add the BitcodeNotSupported category to tests exercising non-bitcode-compatible API.

We have APIs that use exception filter clauses, and we don't support that when
compiling to bitcode.

So mark any tests exercising such API accordingly, so that we can skip those
tests when running tests on targets that use bitcode (watchOS).

* [tests] Use BitcodeNotSupported on applying profiles
2019-02-14 11:49:29 -05:00
Bernhard Urban 920a621367 [bitcode] round up value type size for slot calculation (#12992)
consider

```csharp
struct S3
{
    public ushort X;
    public ushort Y;
    public ushort Z;
}
```
this would be 3 * 2 = 6 bytes. Structs, however, are passed around as i32
arrays in LLVM IR between functions. Those, if such a struct is passed, are
split to int32 depending on the struct's size. The previous calulation was
wrongly reserving one such i32 slot instead of two for `S3` above.

Additionally increase slot size to i64 so that it aligns with a
slightly different ABI on arm64_32.
2019-02-14 14:56:45 +01:00
Alexander Köplinger 9e8317f877 [System.Net.Http] Improve HttpClientTest to use the retry http listener (#12994)
It was missed in https://github.com/mono/mono/pull/11829 so we were still manually
creating HttpListeners which are not hardened against "Address already in use".

Should fix/improve https://github.com/xamarin/maccore/issues/1407.
2019-02-14 11:32:12 +01:00
Zoltan Varga f1ccdc49a9 [runtime] Avoid depending on the layout of the ParameterInfo class in the runtime, netcore has a version with a different layout. (#12980) 2019-02-14 09:32:42 +01:00
Kenneth Pouncey f5084b594f Move the index accessors to TypedArray instead duplicating the logic. 2019-02-14 06:32:37 +01:00
Alexander Kyte 4b83678a4a [crash] Add more detailed reporting for exceptions (#12946)
* [crash] Add more detailed reporting for exceptions

This bumps the crash reporting file format to version 0.0.3.

* [crash] Fix exception stack walker to consider captured_traces

Previously we were missing these frames from the captured_traces fields
of MonoException and MonoStackTrace.
2019-02-13 23:27:17 -05:00
Ludovic Henry e0643e5ac7 [ci] Fix Linux x64 Bitcode job (#12970)
* [ci] Fix Linux x64 Bitcode job

* [ci] Add Bitcode+Interpreter job

* [ci] Improve output information when AOTting the BCL
2019-02-13 18:31:31 -05:00
Alexander Köplinger 1c2ef6a472 Mono.Native: Simplify checking for min-version
We don't need to do the replacement sed magic for the compat library,
it should just use whatever is passed in.
2019-02-13 23:36:07 +01:00
Alexander Köplinger ae507fc4c4 [corlib] Fix CustomAttributeDataTest.MethodIncludesDllImportAttributeData() on watch/tv
Bitcode requires that the native symbol exists.
Changed the pinvoke to something that exists in libc.
2019-02-13 23:35:52 +01:00
Marek Safar 689e9b2e03 Remove local SafeHandle version 2019-02-13 23:24:44 +01:00
Stephen Toub 85caf55c16 Move SafeHandle to managed code and shared (dotnet/coreclr#22564)
* Move SafeHandle to managed code and shared

This moves the implementation of SafeHandle from native code in the runtime to managed.  I used corert's implementation as a base, and reviewed it again against the existing native implementation, making a few tweaks to better match the existing semantics.

This should be a valid move because of the reduced goals around CERs, thread aborts, etc.

However, there are places in the runtime that access SafeHandle functionality via its native counterpart, so I kept the relevant pieces of the native code intact.  Most code will continue to use the managed APIs, but the runtime can continue calling into the native versions when needed.

* Address PR feedback

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 23:24:44 +01:00
Alexander Köplinger c81e675866 [wasm][ci] Disable ChakraCore tests"
Downloading ChakraCore is broken right now due to https://github.com/Microsoft/ChakraCore/issues/5945.
2019-02-13 23:06:12 +01:00
Michal Strehovský 268f9e41cc Annotate EventCounter as a relocated type (dotnet/corert#6990)
This moved to CoreLib and needs to be annotated as such for Project N.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 21:06:20 +01:00
Fei Peng 745499f724 Remove unnecessary ThrowIfUnsupportedType calls and definitions
Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 20:57:02 +01:00
Ludovic Henry bbb71e04a0 [ci] Use testing_aot_full_interp for FullAOT+Interpreter+LLVM (#12976) 2019-02-13 09:56:32 -05:00
Kenneth Pouncey 49d1d1795b Add U : struct constraint on TypeArray. Addresses comment review. 2019-02-13 15:38:07 +01:00
Kenneth Pouncey 1f9533a777 Fix delegate call back. Causes memory access crash with AOT. 2019-02-13 14:45:04 +01:00
Aleksey Kliger (λgeek) 5f1a8e7764 [debug-helpers] Include custom modifiers in mono_type_get_desc (#12979)
* [debug-helpers] Include custom modifiers in mono_type_get_desc

* [mini] Print return type in MONO_METHOD_VERBOSE output
2019-02-13 08:38:16 -05:00
Zoltan Varga 2466c2fc79 [netcore] Implement Assembly/AssemblyName/Module.
For RuntimeAssembly, make a fork since the amount of changes is very big. For AssemblyName/RuntimeModule, use the corlib version with some
ifdefs.
2019-02-13 11:11:37 +01:00
Kenneth Pouncey d81f8c7370 Modification of sdk framework build to not include the initialisation of the Bindings as it is now automatic. 2019-02-13 10:46:46 +01:00
Kenneth Pouncey 6dc1f10af1 Add corebindings build module and inclusion AOT
- Conditional include of bindings depending on if  --nobindings is specified.
- Packager: AOT ninja build modifications.
   - Add corebindings build dependency
   - Add bindings_support.j build dependency
   - Remove dependency to add Bindings initialisation to build and mono_config.js
 - Modify runtime.js and runtime-tests.js to remove the bindings initialisation code.
2019-02-13 10:45:12 +01:00
Ludovic Henry a43f1d2909 [sdks] Add mac-{mac32,mac64} targets (#12959)
* [sdks] Add mac-{mac32,mac64} targets

* [sdks] Add configure-* and build-* for CI
2019-02-12 18:57:56 -05:00
Tarek Mahmoud Sayed 469b0a7a0f Index and Range updates (dotnet/coreclr#22331)
* Index and Range updates

* Address @mikedn  feedback

* Address Feedback

* more feedback

* Use Deconstruct in Range.GetOffsetAndLength

* Rename GetArrayRange to GetSubArray

* Temporary disable the old Corefx Range tests

* Return back the TimeSpan test disabling

* Fix Range jit test

* Exclude the jit test

* revert the changes in the jit Range test

* Address Suggested Feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-13 00:01:05 +01:00
Jan Kotas 781bebfdcb Fix CoreRT build breaks - Adjust resource name - Workaround C# compiler/analyzer bug
Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 23:36:22 +01:00
Marek Safar 3f5471a602 Remove local version of GCHandle 2019-02-12 21:19:29 +01:00
Stephen Toub 64a626fa87 Move GCHandle to shared (dotnet/coreclr#22499)
* Move GCHandle to shared

* Cache the handle in a local to make it easier for JIT to generate good code

* Rename m_handle to _handle to match the coding conventions

* Delete isPinned argument for GCHandleInternalCompareExchange

* Add fast path to GCHandle.Alloc/Free FCalls

* Disable outdated test

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 21:19:29 +01:00
Sung Yoon Whang c005351c61 Renaming RuntimeEventSource to NativeRuntimeEventSource (#22533)
* Renaming RuntimeEventSource to NativeRuntimeEventSource

* missed a couple of comments and XPlatEventLogger

* rename DotNETRuntimeEventSource.cs to NativeRuntimeEventSource.cs

* use condition= instead of ifdef

* removing ifdef from NativeRuntimeEventSource.cs

* Fix case for 'eventing' directory in csproj

* Fix unix builds

* This should fix unix build...

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 20:57:00 +01:00
Tanner Gooding 39f83e1925 Add extensions methods for several of the VectorXXX<T> helper methods (#22336)
* Moving several of the Vector128<T> instance methods to be extension methods.

* Moving several of the Vector256<T> instance methods to be extension methods.

* Moving several of the Vector64<T> instance methods to be extension methods.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 19:18:32 +01:00
Marek Safar d0c5bcff23 Fix the build 2019-02-12 18:37:19 +01:00
Marek Safar 27ea466b0b [System.Private.CoreLib] Clean up EqualityComparer 2019-02-12 18:37:19 +01:00
Thays Grazia 5f65ce9f7d [debugger] Reverting part of https://github.com/mono/mono/pull/12114 (#12950)
* [debugger] Reverting part of this commit https://github.com/mono/mono/pull/12114, removing this part the test ShouldCorrectlyStepOverOnExitFromArgsAfterStepInMethodParameter continues working and solve the regressions of 12881.
Inserted a new test that reproduces the regression.
Fixes #12881
2019-02-12 14:20:38 -02:00
Larry Ewing 2b9e5db153 Remove the logic that prepends a line in source references
Remove the hack that injected an extra line with the source
location now that we reference local sources when we can and
fix the Match logic so that it corrects for the difference
between pdbs and chrome breakpoints
2019-02-12 10:06:31 -06:00
Larry Ewing 2dcbeb5548 Use file: urls when when the files exist locally
Unknown schemes (dotnet:) are not well supported by all the
tools that support the chrome DevTools protocol so if the
file exists locally use a file: url rather than a dotnet:
url to reference it.
2019-02-12 10:06:31 -06:00
Larry Ewing 36d26498d4 Handle urlRegex breakpoint requests.
VisualStudio debug agents use urlRegex rather than url
when looking for breakpoint locations so add support for those
requests.
2019-02-12 10:06:31 -06:00
Larry Ewing 419646c960 VSCode expects the decription field to be populated for the variables display 2019-02-12 09:37:01 -06:00
Larry Ewing ce751cbe55 Make sure we add callFrameId so that the debugger populates locals 2019-02-12 09:37:01 -06:00
Michal Strehovský 52d6e18ea6 Ifdef out code that triggers UTC bug (dotnet/corert#7003)
This results in bad codegen on AMD64. I filed a bug internally; hopefully we can get a fix soon.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 16:17:04 +01:00
hamish-rose 412f75a1c5 Add new rounding modes to System.Math, System.MathF (dotnet/coreclr#20815)
* add new rounding modes to MidpointRounding.cs

new modes added to enum
implemented ToZero for double in Math.cs

* ToZero implementation

* implement double and float rounding modes

* updating rounding implementation

now round inline with DecCalc internal round implementation

* small bug fix

also replace var to make things obvious

* update implementation - floor/ceil

code review feedback

* review feedback

add comments, update MathF with floor/ceil

* code review feedback

 - fix comments
 - replace ifelse with switch
 - remove RoundingMode enum from DecCalc

* exclude outdated corefx test

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 16:12:49 +01:00
Larry Ewing 80c10f6307 Merge pull request #12952 from lewing/debugger-proxy-discovery
[Wasm] Proxy More of the DevTools protocol
2019-02-12 08:32:59 -06:00
Kenneth Pouncey 56d77dcce9 Remove unused code 2019-02-12 14:14:12 +01:00
Maxim Lipnin b4370f6e76 Update System.Data.Entity to handle new String overloads (#12680)
* Add new String overloads

* Remove some overloads with non-primitive types

* Remove IndexOf overloads with more than 1 argument

* Remove Trim() from TrimTranslator because CanonicalFunctionDefaultTranslator already supports it.

* Trim/TrimStart/TrimEnd: remove Char parameter overloads; add condition to support parameterless overloads.

* Remove unsupported Char overloads of Contains, IndexOf, StartWith and EndWith methods
2019-02-12 13:59:39 +01:00
Kenneth Pouncey fbaa3db2e0 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-12 13:30:53 +01:00
Kenneth Pouncey 58fe50e028 Add support for CopyTo
- ArraySegment
- primitive array
- memory address CopyTo (IntPtr, offset, count)
2019-02-12 13:16:16 +01:00
Kenneth Pouncey b1f7a22a8b Add CopyFrom implementation and support for
- ArraySegment
- support CopyFrom IntPtr, offset, count to marshal memory pointer from Heap to TypedArray
2019-02-12 10:32:20 +01:00
monojenkins 5374e7ef46 [csproj] Update project files 2019-02-12 08:52:42 +01:00
monojenkins e4303ac76f Bump API snapshot submodule 2019-02-12 08:52:42 +01:00
Alexander Köplinger 6474cf7b61 Bump cecil submodule 2019-02-12 08:52:42 +01:00
Zoltan Varga 19d705c69d [bcl] Restructure the Module classes to simplify netcore integration.
* Move all icalls to RuntimeModule.
* Make all icalls static and receive the module as an IntPtr.
* Remove some duplicate code between the RuntimeModule and ModuleBuilder classes.
2019-02-12 08:46:09 +01:00
Dotnet-GitSync-Bot 374f44ebe8 Mirror changes from mono/corert,coreclr (#12951)
* Make Module partial to allow additional changed for Mono

Signed-off-by: dotnet-bot <[email protected]>

* Move ConditionalWeakTable to shared (dotnet/coreclr#22531)

Leaves DependentHandle as being the runtime PAL

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 01:45:39 -05:00
Larry Ewing 85bf22730b Proxy More of the DevTools protocol
Much of the tooling around DevTools expects
actions under /json to return useful data
this adds adds some simple logic to proxy those
so that you can point tooling directly at the
proxied port and get responses you expect
2019-02-11 21:18:15 -06:00
Larry Ewing a51b475173 Merge pull request #12809 from lewing/wasm-debug-documentation
[WASM] debug documentation and sample updates
2019-02-11 20:08:54 -06:00
Marek Safar ac5ab1a7ef Use shared Volatile 2019-02-12 00:32:45 +01:00
Stephen Toub 9d136f9446 Move Volatile to shared (dotnet/coreclr#22523)
* Move Volatile to shared

This largely takes corert's implementation, which uses Unsafe.As and volatile fields.

We could investigate also removing the JIT's replacements subsequently.

* Add [Intrinsic] attributes

Signed-off-by: dotnet-bot <[email protected]>
2019-02-12 00:32:45 +01:00
Alexander Köplinger 6ca20e92b6 [ci] Bump timeout for corlib-xunit tests
See https://github.com/mono/mono/issues/12945
2019-02-11 20:34:04 +01:00
Kenneth Pouncey 17134ec2b6 Add support for CopyFrom
- Array, offset, count
- ArraySegment
2019-02-11 17:13:45 +01:00
Bernhard Urban aac567ff66 [ios] add crosswatch64_32 target (#12893)
* [ios] add crosswatch64_32 target

* fix gnu triple for wasm
2019-02-11 11:08:02 -05:00
Alexander Köplinger ff7fc7e93a [ci] Bump bockbuild to get fontconfig download url fix 2019-02-11 16:56:46 +01:00
Aleksey Kliger (λgeek) 95f31d0259 [runtime] Refactor pinvoke probing, part 2 (#12850)
* [marshal] Add emit_exception_for_error callback

* [runtime] MonoError-ize mono_lookup_pinvoke_call_internal

Two complications:

1. Marshalling needs to turn a MonoError into MethodBuilder instructions to
   emit an exception.
2. The public API uses two string to signal an error.  So we have to use
   a custom status struct to return the error code.

* [loader] Factor out library path transformations

* [marshal] Copy error msg in mono_mb_emit_exception_for_error

Add new mono_mb_stdrup to make a copy of a given string into the memory that
will live with the MethodBuilder's method.

* [interp] Callvirt of an icall should call the wrapper.

See pinvoke2.cs test_0_missing_virtual_pinvoke_method ()

You can have an icall override a virtual method:

    	public class T2 : T {
    		[MethodImplAttribute(MethodImplOptions.InternalCall)]
    		public override extern object MyClone ();
    	}

When the interpret saw this, it was setting up a child frame with the frame
method being the MonoMethod of the icall itself, not the wrapper.  But it was
executing the wrapper.  As a result if the wrapper body had a LDSTR in it, we
would hit the assertion in the MINT_LDSTR_TOKEN case where
frame->imethod->method->wrapper_type == MONO_WRAPPER_NONE is not allowed.

With this change the frame method is now the wrapper which has a correct
wrapper type.

* [loader] remove pinvoke_probe_transform_path do{}while(0) construct

take the line damage; make the code easier to understand.
2019-02-11 10:49:56 -05:00
Jonathan Chambers 7176289621 Grow StackSlotInfo array rather than asserting (#12829) 2019-02-11 09:28:48 -05:00
Johan Lorensson dad67f4760 Incorrect call to MONO_HANDLE_SETRAW causes random crash in sgen. (#12851)
mono_string_utf16_to_builder_copy incorrectly uses MONO_HANDLE_SETRAW to
update the chunkLength field with a string length. Since MONO_HANDLE_SETRAW
assumes the argument is a MonoObject reference this could lead to a dereference
and since the value is a string length, that dereference will lead to a crash.

The problem happens in mono_gc_wbarrier_set_arrayref_internal where vtable
is retrieved from value. The crash happens randomly since it is depending
on the object being moved out of the nursery + sgen_binary_protocol_wbarrier
not being eliminated.

Fix is to use MONO_HANDLE_SETVAL since the value is not a reference so no need
to trigger a write barrier.
2019-02-11 09:12:20 -05:00
Johan Lorensson 4ba6733438 Fix OP_GET_LAST_ERROR codegen on Windows x64 full AOT. (#12853)
Current codegen incorrectly read back last error when doing p/invoke for
full AOT. This caused many failed corlib tests ~600. It also
turns out that the test for set/get last error related to p/invoke that we
have in pinvoke2.exe, is not run for the full AOT profile, due to other tests
depending on none full AOT features. In order to make sure we run the test
and not regress, test has been moved into its own runtime tests, running as
part of full AOT testing.
2019-02-11 09:11:50 -05:00
Alexander Kyte 9531662837 [crash] Use safer invalid-free test (#12864)
When using the previous test, some memory unsafety was
observed. It's rather unrecoverable memory unsafety, as
it corrupts heap memory used by the sequence points, registered MERP
paths, jit info internals, and output string.

Crashes seen here: https://github.com/mono/mono/pull/12387 reproduce
with less than 100 iterations of this malloc test run as the stress
test.

```
(MonoJitInfoTable) $2 = {
  domain = 0x5050505050505050
  num_chunks = 1347440720
  num_valid = 1347440720
  chunks = {}
}
```

with

```
(lldb) p/x 1347440720
(int) $0 = 0x50505050
```

And sometimes the mono crash

```
(lldb) p *it
(SeqPointIterator) $3 = {
  seq_point = (il_offset = 0, native_offset = 0, flags = 0, next_offset = 0, next_len = 0)
  ptr = 0x5050505050505050 <no value available>
  begin = 0x5050505050505050 <no value available>
  end = 0x5050505050505064 <no value available>
  has_debug_data = 0
}
```

===

These do not reproduce when doing a double free of legally allocated
memory.

I think that the crash reporting tests aren't the place to check if the
OS allows for wild heap corruption when doing these things. I don't
think it's currently in scope for the runtime to do crash reporting
after it's internal metadata tables have been corrupted. They're the
source of truth for symbolication. We don't have many options to
validate and reparse them, unless we want to make this all very
heavyweight.
2019-02-11 09:11:11 -05:00
Johan Lorensson 1a3813e899 Fix errors in TimeZoneInfoTest on Windows full AOT using winaot profile. (#12852)
Fix errors in TimeZoneInfoTest on Windows full AOT using winaot profile.
2019-02-11 08:35:54 -05:00
Kenneth Pouncey 949f3f7125 Add implicit conversion to and from primitive array. 2019-02-11 13:49:30 +01:00
Kenneth Pouncey 0e1a202bbb Add Type Array CopyFrom support.
- This will copy a managed array from heap to the typed array memory.
2019-02-11 10:29:02 +01:00
Marek Safar d5147e88bb [System.Private.CoreLib] Add more APIs 2019-02-11 09:50:36 +01:00
Kenneth Pouncey 56021009aa Misspellings 2019-02-11 07:37:03 +01:00
Kenneth Pouncey 07bb573833 Merge branch 'master' of https://github.com/mono/mono into wasm-typed-arrays 2019-02-11 06:09:05 +01:00
Vlad Brezae 846eca0dbd [interp] Fix ldelema (#12903)
The ldelema IL instruction provided the element class while the Address intrinsic provided the array class.

Fixes https://github.com/xamarin/xamarin-macios/issues/5363
2019-02-11 01:09:06 +02:00
Calvin Buckley b2f590b599 Fix build and use System.Native on FreeBSD (#12921)
* Required includes for system headers to behave on FreeBSD

* System.Native on FreeBSD
2019-02-10 10:27:54 +01:00
Jan Kotas b98780c71b Fix casing of interop directories (dotnet/corert#6982)
Match convention introduced by https://github.com/dotnet/corefx/pull/35085

Signed-off-by: dotnet-bot <[email protected]>
2019-02-10 09:37:18 +01:00
Sung Yoon Whang 544c43d0d6 set up CoreLib to include EventCounter in build project (#22501)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-10 09:32:05 +01:00
Marek Safar ca418e412b [netcore] Update to the latest version 2019-02-09 17:31:41 +01:00
Alexander Köplinger 67f1926803 [ci] Fix windows job name in osx-package.groovy 2019-02-09 14:32:27 +01:00
Marek Safar 903b264c4f Move Array's SZGenericArrayEnumerator to shared partition (#22480)
* Move Array's SZGenericArrayEnumerator to shared partition

* Remove legacy comment

* Move all array enumerators to a new file

Signed-off-by: dotnet-bot <[email protected]>
2019-02-09 08:30:10 +01:00
monojenkins 1f330171a8 [bcl] Update BCL Linked Size 2019-02-09 08:27:25 +01:00
Sung Yoon Whang 3fa2c0511f move EventCounter to shared CoreLib (dotnet/corefx#35183)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-09 08:25:51 +01:00
Marek Safar 5f9b66db43 [System.Private.CoreLib] Add missing Array APIs 2019-02-09 08:23:04 +01:00
Grant 29942cfd80 BitOps.TrailingZeroCount has inconsistent software fallback (#22333)
Fix #22326

Signed-off-by: dotnet-bot <[email protected]>
2019-02-09 00:58:07 +01:00
Marek Safar 38550e117e [System.Private.CoreLib] Implement part of GCSettings 2019-02-09 00:08:20 +01:00
Marek Safar 54f35f6198 Clean up GCSettings temp version 2019-02-08 23:15:15 +01:00
Stephen Toub 4bb7d23683 Move GCSettings to shared (dotnet/coreclr#22483)
Mainly just type definitions and error handling that gets shared.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 23:15:15 +01:00
Ludovic Henry f804ffdd2c Merge pull request #12810 from lateralusX/lateralusX/fix-win-fullaot-runtime-tests
Fix Windows x64 full AOT runtime test failures.
2019-02-08 15:50:03 -05:00
Ludovic Henry 719668fda1 Merge pull request #12856 from migueldeicaza/registry-finalizer-fixed
[Registry] Prevent crash due to background thread facing problems in the file system
2019-02-08 15:44:23 -05:00
Ludovic Henry 2355e592dc [arm/bitcode] mark valuetype returns as such when dealing with pinvokes (#12894)
On armv7 our calling convention happens to be the same as the platform
one. However, when using a armv7 cross compiler to generate bitcode that
targets a different platform (e.g. arm64_32) the calling convention can
be different (e.g. on arm64_32, a return buffer must be passed via r8).
Thus, mark it properly for LLVM so it can generate correct code.
2019-02-08 15:38:00 -05:00
Bernhard Urban 8ad82bbfc1 [ios] link mono-native correctly (#12895)
Fixes this app startup issue

```
dyld: Library not loaded: /Users/lewurm/work/mono-watch4-ios-sdk/sdks/out/ios-target64-release/lib/libmono-native-unified.0.dylib
  Referenced from: /var/containers/Bundle/Application/9697C8F3-811C-4BF3-B1BC-1E6385673984/PublicStaging.app/test-Mono.Runtime.Tests
  Reason: image not found
Process 2269 exited with status = 0 (0x00000000) Terminated due to signal 6
```
2019-02-08 15:36:53 -05:00
Vlad Brezae b62cca8974 [interp] Remove some cknull uses (#12849)
* [interp] Avoid using MINT_CKNULL

Unnecessary overhead for this tiny instruction.

* [interp] Do null check for this before inlining

Otherwise we miss it.
2019-02-08 15:32:07 -05:00
Vlad Brezae edccda13d3 [interp] Add method to seq_points table after we finish registering it (#12902)
* [interp] Add method to seq_points table after we finish registering it

When adding a breakpoint (mono_de_set_breakpoint) we search in this table for seq_point information for the method. If we find the information we expect that the method is already compiled and has the metadata initialized when actually adding the breakpoint (set_bp_in_method). We were crashing if the jinfo field of the interp method was not yet initialized.

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

* [interp] Move profiler callback when we are actually done

Just in case.
2019-02-08 15:29:07 -05:00
Jan Kotas b8ee1ca51f Update CoreRT with shared array implementation
Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 19:58:21 +01:00
Zoltan Varga f1dfd9c413 [llvmonly] Add a mini_llvmonly_throw_nullref_exception () jit icall to throw nullref exceptions, it occurs very frequently when explicit null checks are enabled. (#12883) 2019-02-08 13:06:11 -05:00
Zoltan Varga e14ef8a658 [corlib] Move the implementations of virtual methods from Assembly to RuntimeAssembly to ease netcore integration. (#12805)
* [corlib] Move the implementations of virtual methods from Assembly to RuntimeAssembly to ease netcore integration.

* [corlib] Move more code to RuntimeAssembly.

* [corlib] Move fields from Assembly to RuntimeAssembly/AssemblyBuilder.cs. Reduce the amount of fields visible to runtime code.

* Update serialization tests.

* Fix the MOBILE build.

* Bump API snapshot submodule
2019-02-08 13:05:54 -05:00
Zoltan Varga 83fc1456db [wasm] Add mixed tests to CI. (#12882)
* [wasm] Only dedup the assemblies which are actually AOTed in mixed mode.

* [wasm] Add mixed mode test targets.

* [wasm] Add mixed tests to CI.
2019-02-08 13:05:35 -05:00
Alexander Köplinger b01cfed2a4 [ci] Support building the OSX .pkg on private Jenkins 2019-02-08 17:18:41 +01:00
Alex Thibodeau d5dfaf6006 FIxing crash where a generic enum is passed into get_shared_type. Also added automated test to catch this scenario. (#12622) 2019-02-08 09:27:54 -05:00
Bernhard Urban b9c611e93c [arm64] encode offset within stack slot for r4 in gsharedvt descriptor (#12867)
Follow up fix for https://github.com/mono/mono/pull/11741

Fixes https://github.com/mono/mono/issues/12831
2019-02-08 12:28:29 +01:00
Bernhard Urban 63f4ee5540 [arm/bitcode] mark valuetype returns as such when dealing with pinvokes
On armv7 our calling convention happens to be the same as the platform
one. However, when using a armv7 cross compiler to generate bitcode that
targets a different platform (e.g. arm64_32) the calling convention can
be different (e.g. on arm64_32, a return buffer must be passed via r8).
Thus, mark it properly for LLVM so it can generate correct code.
2019-02-08 11:17:06 +01:00
Aleksey Kliger 972f29179d [sre] Handle null values in MarshalAsAttribute CustomAttributeBuilder
Normally strings are encoded as length-then-utf8 in ECMA-335.  But a null
String is encoded as just the byte 0xFF.

When we make a CustomAttributeBuilder for a MarshalAsAttribute and attach it to
some parameter we first encode the CAB as a byte blob and then decode it in
CAB.get_umarshal into a UnmanagedMarshal attribute.  But the decoding didn't
account for the possibility of null strings.

Fixes https://github.com/mono/mono/issues/12747
2019-02-08 10:56:08 +01:00
Marek Safar 49c0a9c2de Remove local DateTime 2019-02-08 10:37:29 +01:00
Marek Safar 9636096e3b Move DateTime for Unix to shared partition (dotnet/coreclr#22383)
* Move DateTime for Unix to shared partition

* Keep CoreCLR specific implementation

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:37:29 +01:00
Marek Safar f4c9b79905 Use local Array version 2019-02-08 10:27:04 +01:00
Stephen Toub a4681c14d9 Fix CoreLib to include PasteArguments.Unix.cs correctly (#22453)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Marek Safar 2e267dfa80 Move Array to shared partition (dotnet/coreclr#22321)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Marek Safar 8608d281c6 Implement ManifestBasedResourceGroveler::GetNeutralResourcesLanguageAttribute (#22372)
* Implement ManifestBasedResourceGroveler::GetNeutralResourcesLanguageAttribute in shared managed code

* Remove native ::GetNeutralResourcesLanguage

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Tarek Mahmoud Sayed ab717125aa Index and Range updates (dotnet/coreclr#22331)
* Index and Range updates

* Address @mikedn  feedback

* Address Feedback

* more feedback

* Use Deconstruct in Range.GetOffsetAndLength

* Rename GetArrayRange to GetSubArray

* Temporary disable the old Corefx Range tests

* Return back the TimeSpan test disabling

* Fix Range jit test

* Exclude the jit test

* revert the changes in the jit Range test

* Address Suggested Feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-02-08 10:27:04 +01:00
Bernhard Urban 33d6380103 [aot] interp flag on AOT images only on mscorlib required (#12838)
[aot] interp flag on AOT images only on mscorlib required

/cc @spouliot. This fixes `--interpreter=-all` on Xamarin.iOS.
2019-02-07 17:15:50 -05:00
Bernhard Urban 21c65aafc8 [ios] pass --enable-monotouch to cross compilers so icall defintions are visible to it (#12834)
This fixes a regression introduced by https://github.com/mono/mono/commit/5187b0bdaaff56936d697b0753dad51e7498991d

The AOT compiler wasn't aware of the icalls since they are guarded by `ENABLE_MONOTOUCH`. Passing `--enable-monotouch` to configure of the AOT compiler enables that define, so it can properly resolve those icalls. However, to avoid `zlib` dependency for the cross compilers, we stub
them out.
2019-02-07 20:26:42 +01:00
Alexander Kyte 0e65799c8e [runtime] Use temp folders for merp tests (#12830)
The 2018-10 lane seemed to be failing some tests because the merp-json-valid.exe test left behind the crash log file. I fixed that in this PR, but also move the tests into their separate folders so they can run at the same time safely.
2019-02-07 19:32:06 +01:00
Tanner Gooding 321e0b511f Fixing Utf8Formatter.Float to support all the same format specifiers as the utf16 formatter. (#22434)
* Fixing Utf8Formatter.Float to support all the same format specifiers as the utf16 formatter.

* Disabling some outdated CoreFX tests.

* Fixing TryFormatFloatingPoint to special-case format.IsDefault

Signed-off-by: dotnet-bot <[email protected]>
2019-02-07 18:47:19 +01:00
Stephen Toub 75a7b9601f Finish removing Environment from corefx
Signed-off-by: dotnet-bot <[email protected]>
2019-02-07 18:30:59 +01:00
Miguel de Icaza 39397b5e92 [Registry] Prevent crash due to background thread facing problems in the file system 2019-02-07 11:52:59 -05:00
Zoltan Varga b019ca4d5a [wasm] Fix icall table linking, generate one table per assembly. (#12840) 2019-02-07 11:44:11 -05:00
Vlad Brezae 33189ef31f [tests] Enable test suites on interpreter (#12806)
Seem to pass locally
2019-02-07 16:13:24 +02:00
Johan Lorensson bbe84c03fa Merge pull request #12811 from lateralusX/lateralusX/fix-win-fullaot-runtime-tests-toggleref
Fix issue where togglerefs might be incorrectly pinned by GC.
2019-02-07 02:59:45 -05:00
Kenneth Pouncey dedbbbf401 Fix error with bindings. 2019-02-07 07:09:08 +01:00
Aleksey Kliger (λgeek) d36f437f60 [runtime] Refactor pinvoke probing (#12795)
* [runtime] Mark mono_lookup_pinvoke_call external only

Runtime should use mono_lookup_pinvoke_call_internal

* [loader] Factor out helper functions from mono_lookup_pinvoke_call

Separate the logic for probing for a dynamic library module from the logic for
looking for a symbol inside the module.

* [loader] Factor out relative directory probing in pinvoke lookup
2019-02-06 20:50:32 -05:00
Zoltan Varga 9453281f0c [ci] Enable llvmonly+mixed tests on CI. (#12777) 2019-02-06 20:46:06 -05:00
Alexander Köplinger 004deafa3a [tests] Disable flaky block_guard_restore_aligment_on_exit.exe on Windows PRs
See https://github.com/mono/mono/issues/12839
2019-02-07 01:25:13 +01:00
Thays Grazia ada7c1b821 [wasm][debugger] Bug on attributes with value type string and content NULL (#12827)
* An attribute with a content that was a string null was creating two items in result json and it was throwing an exception in client side because it is expected a name and a value and not a name and two values.
2019-02-06 21:19:01 -02:00
Alexander Köplinger ea3d9b80b5 [corlib] Remove reflection-based Mono.Native test (#12828)
The managed linker removes the type embedded inside mscorlib and we don't want to whitelist it in linker xml since then it'd be kept for everyone.

Instead move the type to the test assembly and remove the reflection-based tests.
2019-02-06 22:47:19 +01:00
Miguel de Icaza b3eeb1667a [man] mono.1 - describe how to get the list of options 2019-02-06 15:52:19 -05:00
Alexander Köplinger b4c66a1d59 [mono-native] Remove accidentally added brotli.c file
It broke the iOS SDK build because of duplicated main().

See https://github.com/mono/mono/pull/12189
2019-02-06 20:50:50 +01:00
Alexander Köplinger 04c71af56a Extend mono-native minimum version magic to CPPFLAGS/CXXFLAGS (#12801)
We were only doing the -mmacosx-min-version replacement magic on
CFLAGS and LDFLAGS for mono-native-compat and -unified,
but we need to do the same for CPPFLAGS/CXXFLAGS too.

Fixes an issue where the libraries were targeting the wrong minimum OSX
version when built from xamarin-macios since they pass the minimum version
in CPPFLAGS instead of CFLAGS for OSX.
2019-02-06 19:07:58 +01:00
Martin Baulig 5c17c4cf31 Add support for async-streams (C# 8.0). (#12674)
Bring some new APIs from corefx master for async-streams (C# 8.0):

- `IAsyncDisposable`
- `IAsyncEnumerable`
- `IAsyncEnumerator`
- `AsyncIteratorMethodBuilder`
- `AsyncIteratorStateMachineAttribute`
- `ConfiguredAsyncDisposable`
- `ConfiguredCancelableAsyncEnumerable`
- `ManualResetValueTaskSourceCore`
- `TaskExtensions` (replacing our reference source version).

Minor changes to existing code:

- Add `ExecutionContext.ContextCallback<TState>(ref TState state)` delegate.
- Add `ExecutionContext.RunInternal<TState>` method.
- Uncomment `AsyncMethodBuilderCore.Start<TStateMachine>`.
- Add new `ThreadPool.QueueUserWorkItem<T>(Action<T>,T,bool)` and `UnsafeQueueUserWorkItem<T>(Action<T>,T,bool)` overloads.

New xUnit tests from CoreFX:

- `System.Threading.Tasks/tests/System.Runtime.CompilerServices/ConfiguredCancelableAsyncEnumerableTests.netcoreapp.cs`
- `System.Threading.Tasks.Extensions/tests/ManualResetValueTaskSourceTests.cs`
- `System.Threading.Tasks.Extensions/tests/ValueTaskTests.cs`
- `Common/tests/System/Threading/Tasks/Sources/ManualResetValueTaskSource.cs`
- `Common/tests/System/Threading/Tasks/Sources/ManualResetValueTaskSourceFactory.cs`
- `System.Threading.Tasks.Extensions/tests/AsyncValueTaskMethodBuilderTests.cs`
- `System.Threading.ThreadPool/tests/ThreadPoolTests.cs`
- `System.Threading.ThreadPool/tests/ThreadPoolTests.netcoreapp.cs` (partial due to missing `IThreadPoolWorkItem`)
2019-02-06 15:01:45 +01:00
Kenneth Pouncey fdc3d56c9b Typed Array Support - Initial commit
- Contains breaking changes
  - Remove NewArrayJS which is replaced with Array bidning.
- Add support for working with Typed Arrays, ArrayBuffer and Array.
-  Typed arrays supported

   - Int8Array 		| int8_t	| byte or SByte (signed byte)
   - Uint8Array		| uint8_t	| byte or Byte (unsigned byte)
   - Uint8ClampedArray| uint8_t	| byte or Byte (unsigned byte)
   - Int16Array		| int16_t	| short (signed short)
   - Uint16Array		| uint16_t	| ushort (unsigned short)
   - Int32Array		| int32_t	| int (signed integer)
   - Uint32Array		| uint32_t	| uint (unsigned integer)
   - Float32Array		| float		| float
   - Float64Array		| double	| double

- Split the bindings into separate file for easier support and to keep the driver program size down.
2019-02-06 14:52:30 +01:00
Thays Grazia e1602576d3 [wasm][debugger] Evaluate properties and generics. (#12782)
* [wasm][debugger] Evaluate properties and generics.
2019-02-06 09:39:00 -02:00
Alexander Köplinger aedc1ca38f [ci] Support Mono version 6.x in Windows .msi build 2019-02-06 11:47:02 +01:00
Vlad Brezae 7869333c52 [metadata] Fix dynamic delegate (#12762)
* [metadata] Decouple dynamic method signature from its delegate invoke wrapper

The invoke wrapper should not be referencing the signature because it will be freed once with the dynamic method. The wrapper can outlive the dynamic method, it is cached based on the signature.

Fixes crash on old IronJS benchmark with interpreter (which uses a lot of delegate wrappers, compared to jit)

* [interp] Add debug method for printing transformed code
2019-02-06 11:19:26 +01:00
Larry Ewing 5b44b5cbb8 Update README.md debugger instructions to match the current layout 2019-02-05 19:42:17 -06:00
Larry Ewing 1ea56466e4 Include mono-config.js produced by packager in debug.html 2019-02-05 19:41:37 -06:00
Larry Ewing d4251f42f4 Remove shell prompt from README.md to be consistent and improve cut and paste 2019-02-05 19:39:04 -06:00
Larry Ewing 879afec442 Merge pull request #12540 from jeromelaban/dev/jela/wasm-debugger-update
[WASM] Improve debugging support
2019-02-05 19:01:30 -06:00
Egor Bogatov 2f6104f163 [System.IO.Compression] Brotli from CoreFX (#12189)
Resolves https://github.com/mono/mono/issues/11431

I put the native impl to Mono.Native, but probably it should be in a separate lib (`libmono-native.0.dylib` before: **81kb**, after: **898kb**) if Linker is not able to trim it if it's not used.
Compiles and works on Windows (however, we don't build Mono.Native for Windows, but we can borrow `clrcompression.dll` from .net core) and macOS but requires changes in mono/corefx,

I disabled xunit tests as those need 50mb of test data.

PS: Brotli could be fully managed 😢 https://github.com/dotnet/corefxlab/issues/1673

C# ports:

- https://github.com/master131/BrotliSharpLib 
A quick benchmark (Compressing a 5mb file with max compression level=11)
Mono JIT: 25sec
Mono LLVM-AOT: 7.8sec
.NET Core 2.2: 6.8sec
.NET Core 3.0: 5.8sec
.NET Core's BrotliStream (with native lib): 3.5sec


- https://github.com/google/brotli/tree/master/csharp - official C# port. Based on Java sources, slow, outdated (2 years ago).
2019-02-06 00:25:19 +01:00
Martin Baulig 94f00fe796 Fix HttpClient on AIX (#12744). (#12771)
Define `PLATFORM_UNIX` in `mcs/build/platforms/unix.make` and make
`mcs/build/profiles/net_4_x.make` define `SOCKETSHTTPHANDLER=1` when set.
2019-02-05 22:41:43 +01:00
Alexander Köplinger fd71ea2fd3 [corlib] Disable GetFrames_AsyncCalls on mobile
See https://github.com/mono/mono/pull/12790
2019-02-05 21:33:56 +01:00
Michal Strehovský 399d14104a Fix ProjectN build breaks (dotnet/corert#6954)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-05 19:13:59 +01:00
lateralusX c432251142 Fix issue where togglerefs might be incorrectly pinned.
Due to current order, process togglerefs and then take current threads
stack could cause a problem where toogleref references might be left
in registers after native code process the list and those reference
would then be put into current thread context, incorrectly pinning the
toggleref, preventing it from being GC:ed. The problem was observed on
Windows (in debug build) running sgen-toggleref.exe runtime test since
the native compile of sgen_process_togglerefs used a register when
walking the list of togglerefs that was then not re-used until the
current threads stack was taken, causing incorrect pinning. This problem
could in theory happen on any platform depending on how sgen_process_togglerefs
would been compiled and what register will be used.

Fix is to take current threads context before walking the togglerefs to make
sure we are not getting managed references into registers as part of managing
the toggleref list in native code.
2019-02-05 18:37:05 +01:00
lateralusX ecc42a8410 Fix failure in catchfault_tail.exe due to stack overwrite in final handler.
Combination of Windows x64 ABI and the lack of not checking for fault handlers
in OP_START_HANDLER cause a hard to track stack corruption when combined with
tail calls. Fix is to make sure we also handle fault regions in handlers to
handle cases like the one exposed by catchfault_tail.exe test.
2019-02-05 18:34:20 +01:00
lateralusX dfa2fe6d2b Add better support to dynamically setup content of config.h in Windows MSVC builds.
When running tests on CI the runtime is configured from autogen.sh script.
When running fullaot there are a couple of features not supported so they are
disabled. The problem is that the MSVC Windows builds have its own winconfig.h
template, losing all the disabled features from configures config.h.

This commit adds support to detect the disable defines from configures config.h
if one exists. Since the complexity of this step increases the work previously
done in winsetup.bat has been moved into a msbuild target that is used from
both within VS build as well as winsetup.bat (there are a couple of other builds
using that bat file, so won't remove it).

The winconfig.h template we had is quite outdated compared to what’s generated
by configure. This commit also updates the winconfig.h to closer match what generated
for corresponding mingw build but keep all the Windows specific configurations
included in current version.
2019-02-05 18:34:20 +01:00
lateralusX c39e3e1200 Fix failing test under debug mode due to incorrect marshal alloc. 2019-02-05 18:34:20 +01:00
lateralusX 46e65d2a09 Fix process stress tests to not popup thousands of Windows.
Fix runtime test run to pickup working wrapper when running
with --enable-msvc but not setting MONO_EXECUTABLE.
2019-02-05 18:34:20 +01:00
Jo Shields 667925b987 Merge pull request #12794 from directhex/master
Bump version to 6.1.0
2019-02-05 11:26:56 -05:00
Jo Shields 1f77041f92 Bump version to 6.1.0 2019-02-05 09:42:19 -05:00
Marek Safar 29594b984c [corlib] Fix GetFrames_AsyncCalls test not to block 2019-02-05 13:09:36 +01:00
monojenkins ae99e720cd [csproj] Update project files 2019-02-05 13:08:33 +01:00
monojenkins b7fe8104e6 Bump API snapshot submodule 2019-02-05 13:08:33 +01:00
Egor Bogatov 4285787ece improve test 2019-02-05 13:08:33 +01:00
Egor Bogatov 5946cd6cb5 use CoreRT's CancellationToken and CancellationTokenSource 2019-02-05 13:08:33 +01:00
Egor Bogatov 56aab1437d add #if MONO to ref-source file 2019-02-05 13:08:33 +01:00
Egor Bogatov 3c9035442b Do not clone SyncronizationContext in EE 2019-02-05 13:08:33 +01:00
Martin Baulig afd4971208 "Ice Blue": Adding some "Connection Info" properties to SslStream. 2019-02-05 10:49:47 +01:00
Zoltan Varga 51287431af [netcore] Ongoing work. (#12750) 2019-02-05 10:34:31 +01:00
Ben Adams 45b6b640a4 Fix string.strlen (dotnet/coreclr#22397)
* Add explanation comment

Fixes #22393

Signed-off-by: dotnet-bot <[email protected]>
2019-02-05 10:29:49 +01:00
Marek Safar dc323ae290 Remove local SynchronizationContext 2019-02-05 10:20:12 +01:00
Marek Safar d2ee660406 Move SynchronizationContext to shared partition (dotnet/coreclr#22389)
* Move SynchronizationContext to shared partition

* Move WaitHelperNative to WaitHandle

Signed-off-by: dotnet-bot <[email protected]>
2019-02-05 10:20:12 +01:00
Vlad Brezae 63fc0ebdfa [interp] Add missing write barrier (#12772) 2019-02-05 09:30:33 +02:00
Jan Kotas 88a621524e More compact implementation of Marshal.GenerateProgIdForType (#22395)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-04 22:53:05 +01:00
Martin Baulig 721a437310 Remove internal WebRequest.RequestCallback to fix a compiler warning. 2019-02-04 22:52:38 +01:00
Thays Grazia 427cdf422e Disable test GetFrames_AsynsCalls for wasm only. (#12768) 2019-02-04 18:09:20 +01:00
Thays Grazia aa08555cfb [wasm][debugger] Add array inspection to the debugger. (#12733)
* [wasm][debugger] Evaluate array variables.

* Prefixing free_objref with mono_debugger_ to "document" that it's a debugger only function.
2019-02-04 10:32:40 -05:00
Aleksey Kliger (λgeek) f7fca0a8a2 [runtime] Switch to GC Unsafe in a few more external API functions (#12738)
* [runtime] Switch to GC Unsafe in mono_property_get_value

It's external only, so it should switch from GC Safe to GC Unsafe when called.

Addresses crash in https://github.com/mono/mono/issues/12724

* [runtime] Make mono_image_loaded external only

Also mono_image_loaded_full

Runtime should use mono_image_loaded_internal

* [runtime] Make mono_get_exception_argument_null external only
2019-02-04 16:10:49 +01:00
Jo Shields 4d9e8f58f8 Bump libgdiplus to mono-2018-12 branch tip 2019-02-04 15:14:14 +01:00
Damien Diederen 1cd74fa1cd [profiler] Avoid native crash with GUID-less assemblies
Without this patch, Mono crashes while writing AOT profiling data at
shutdown (when instructed to do so via --profile=aot:output=out.aotprof)
if any of the sampled methods belong to a dynamic image, which doesn't
have a GUID.

This happens with e.g. the DynamicProxyGenAssembly2 image:

> DynamicProxyGenAssembly2 is a temporary assembly built by mocking
> systems that use CastleProxy like Moq or NSubsitute. It is generated
> when the mock is needed and disposed of after the tests are finished.

(cf. https://stackoverflow.com/a/17179923)
2019-02-04 14:21:57 +01:00
Filip Navara 7d53edefa2 Remove code that was moved to System.Native (dotnet/corert#6932)
* Remove code that was already moved from System.Private.CoreLib.Native to System.Native.

* Move Interop files for System.Native to shared Interop directory.

* Add FeaturePortableThreadPool conditions to csproj files.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-04 14:18:40 +01:00
Mikhail Filippov 8a6d0028bd Use LoadFrom instead LoadFile for load logger type.
LoadFile lost assembly load-context. If the logger assembly has any dependencies placed in same folder logger can't load it. Main.cs using LoadFrom to load assembly but assembly already loaded in the cache after GetLoggerTypeName.
2019-02-04 14:14:53 +01:00
monojenkins 0ea6711572 [csproj] Update project files 2019-02-04 13:53:27 +01:00
monojenkins 3ad59586bf Bump API snapshot submodule 2019-02-04 13:53:27 +01:00
Egor Bogatov 7b0cd424db Copy refs from CoreFX 2019-02-04 13:53:27 +01:00
Marek Safar 81f5873758 [System.Private.CoreLib] Use local string version 2019-02-04 13:52:51 +01:00
Marek Safar bb5feb2579 [System.Private.CoreLib] Add Nullable runtime support 2019-02-04 09:44:40 +01:00
Michal Strehovský cc4c2b03d6 Throw the right exception when interface dispatch is ambiguous (#22295)
Throw the approved exception per dotnet/corefx#34124.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-03 22:04:43 +01:00
Filip Navara 4b88f5c167 Move Interop.GetTimestamp.cs to shared CoreLib partition. (#35031)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-03 21:34:31 +01:00
Marek Safar 03f07724b3 [System.Private.CoreLib] Fix the build 2019-02-02 23:05:22 +01:00
Zoltan Varga 6bc1e59d69 [runtime] Rename more MonoX->RuntimeX classes. (#12732) 2019-02-02 21:36:49 +01:00
Stephen Toub d0c54c546a Avoid delegate/work item allocations when setting async continuation (#22373)
When awaiting a task, there's a race between seeing whether the task has completed (in which case we just continue running synchronously), finding the task hasn't completed (in which case we hook up a continuation), and then by the time we try to hook up the continuation finding the task has already completed.  In that final case, we don't want to just execute the callback synchronously, as we risk a stack dive, so we queue it.  That queueing currently entails two allocations in the common case: one for the work item object, and one for the Action delegate we force into existence for the state machine box's MoveNext method (in the common case it's now never allocated because you only await Tasks and ValueTasks known to the runtime, which bypasses its creation).  We can instead just queue the box itself, and avoid both allocations.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 21:24:16 +01:00
Jan Kotas 3496691706 Rename ResourceManager fields to follow conventions (dotnet/coreclr#22371)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 20:02:34 +01:00
Lee Culver cab519ca07 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-02 15:18:28 +01:00
Marek Safar a7277849e7 Remove Mono implementation 2019-02-02 09:54:49 +01:00
Marek Safar 89c8d135eb Move Marshal::UnsafeAddrOfPinnedArrayElement to shared partition (#22359)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 09:54:49 +01:00
monojenkins 15e7ec70de [bcl] Update BCL Linked Size 2019-02-02 09:44:42 +01:00
Alexander Köplinger 2c8fe4fdc2 [bcl] Use delaysign for nunit/nunitlite
Otherwise mcs won't build it.
2019-02-02 01:17:59 +01:00
Marek Safar 598426a7ae Remove local ResourceManager 2019-02-02 00:20:35 +01:00
Stephen Toub b2226867ae Remove stale warning 420 pragmas (dotnet/coreclr#22352)
It used to be that the CS0420 warning ("a reference to a volatile field will not be treated as volatile") would fire when a volatile was used with an Interlocked.* operation.  That warning was unnecessary, as Interlocked.* would itself provide the relevant barriers, and these functions were special cased in Roslyn a long time ago.  But there are still lots of places where pragmas disabling the warning have stuck around.  I'm deleting them all.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 00:20:35 +01:00
Filip Navara 21fca52b3d Move ResourceManager to shared CoreLib. (dotnet/coreclr#22249)
* Move ResourceManager to shared CoreLib.

* Split UAP code out of ResourceManager.cs into separate files.

* Remove ResourceManager.NonUap.cs.

* Do not access internal field (CoreRT build fix).

* Fix non-Windows builds (CoreRT).

* Remove obsolete Debug code.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-02 00:20:35 +01:00
Alexander Köplinger 31e170fd3e [bcl] Actually fix the nunit/nunitlite assembly identity (#12743)
The solution from https://github.com/mono/mono/pull/12725 doesn't fully work
since e.g. gacutil seems to verify the strong name.

Instead follow what we do for other keys where we don't have the private key:
add them to the machine.config pubTokenMapping list.
2019-02-01 23:33:36 +01:00
Alexander Köplinger 260cc5411d Fix tarball build 2019-02-01 23:15:00 +01:00
Maxim Lipnin cd2d903518 Avoid recursive extracting redundant frames from captured traces. 2019-02-01 23:05:25 +01:00
Tanner Gooding 40eb410e73 Update the double/float formatters to return the shortest roundtrippable string. (#22040)
* Updating Number.Formatting to always compute a round-trippable number by default.

* Adding a third-party notice entry for the Grisu3 reference implementation

* Fixing up the Grisu3 algorithm to better match the reference implementation (including comments, etc)

* Porting the Grisu3 implementation that generates the shortest roundtrippable sequence.

* Updating the Dragon4 algorithm to support printing the shortest roundtrippable string.

* Fixing the double/float formatters to ignore precision specifiers for 'R'

* Fixing the double/float formatters to handle +0.0 and -0.0

* Fix the casing of `point` in THIRD-PARTY-NOTICES

Co-Authored-By: tannergooding <[email protected]>

* Fixing the double/float formatting code to consider a precision specifier of 0 to be the same as default.

* Fixing the double/float formatter so that nMaxDigits is set appropriately.

* Changing the double/float formatting logic to account for the format when determining the correct precision to request.

* Updating the double/float formatter to take the format specifier into account when determining the number of digits to request.

* Fixing the double/float formatting code to continue handling zero correctly.

* Disabling some outdated CoreFX tests.

* Responding to various feedback from the PR

Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 22:28:08 +01:00
Alexander Köplinger 2d715b1af2 Fix tarball build 2019-02-01 20:59:54 +01:00
Alexander Köplinger acc902614e [bcl] Fix assembly identity of nunit/nunitlite (#12725)
* [bcl] Fix assembly identity of nunit/nunitlite

The new strong name key added in https://github.com/mono/mono/commit/acaa73b7026897f7e83a101a9bc331476b5ed169
changed the assembly identity which we can't do for shipping libraries.

Given that the old .snk is invalid (see https://github.com/dotnet/roslyn/issues/32502),
we just sign with the extracted public key and /publicsign.

For MCS_MODE builds we instead use the mono.snk since mcs doesn't support /publicsign
and we don't really care about having the correct identity there.

* [csproj] Update project files
2019-02-01 20:58:54 +01:00
Johan Lorensson 7710b4c099 Add support for Windows x64 winaot, winaot_llvm builds/tests on CI. (#12601)
Add support for building Windows x64 fullaot version of winaot profile
that can be run on CI. Initial changes also add execution of mini regression
tests on CI. More tests will be added going forward and when having full
pass rate.

Add support for building Windows x64 fullaot+llvm version of winaot profile
that can be run on CI. Initial changes also add execution of mini regression
tests on CI. More tests will be added going forward and when having full
pass rate.

In order to get deterministic build results and working build on CI, we need
to setup a correct build environment for the MSVC builds. Since MSVC build is
currently run from cygwin, there are environment problems, both general
but also in our CI environment, since we add cygwin bin folder to system path
(needed by Jenkins plugin). When running more complex cmake builds like
BTLS and LLVM, this will cause problems picking up incorrect tools,
failing builds on CI.

Another problem is the AOT compilation using MSVC toolchain. In the
past CI used some "hard coded paths" to make sure clang.exe and link.exe was found.
This is not optimal and won't work when including LLVM as part of full AOT since
link.exe will need access to more of the full build environment setup by VS
development environments (like platform libraries).

In order to get a better build environment on CI this commit includes and enhance
a couple of build scripts used to run msbuild.exe and mono-sgen.exe (as AOT compiler)
in a VS development environment, isolate that build process from cygwin environment.

The build scripts will locate installed VS tooling, VS2015 build tools or VS dev env,
VS2017 build tools or VS dev env and use corresponding development environment
scripts as part of running msbuild.exe and mono-sgen.exe in AOT mode.

In order to make sure mono-sgen.exe as AOT compiler is run through these scripts
an additional environment variable MONO_EXECUTABLE_WRAPPER is introduced and used
in mono-wrapper when set. Without this indirection there will be problems on CI
tests since the environment is using MONO_EXECUTABLE and pass that into for example
test driver that run child processes of mono-sgen.exe, meaning that we can't
use scripts for MONO_EXECUTABLE, but splitting the MONO_EXECUTABLE to represent
mono runtime and have a MONO_EXECUTABLE_WRAPPER that could be a launch script
solves this issue.

This commit also includes several smaller fixes made to the generic
fullaot build infrastructure.

Fix additional msbuild arguments.

Add Mono.SIMD assembly to winaot profile.

Run msbuild.exe as part of .bat file.
2019-02-01 11:54:45 -05:00
Marek Habersack dc1cdb9983 [bcl] Fix possible deadlock race in CSharpCodeGenerator (#12685)
`CSharpCodeGenerator` runs a compiler while redirecting its standard error and
standard output streams for further reporting. However, in doing that it fails
to read the standard output data completely and also fails to properly wait for
the standard error output to complete. Depending on environment it may lead to
the process using `CSharpCodeGenerator` hanging while the process has already
exited but there still is data to be read from standard output and standard
error.

This commit changes the code to an implementation of reading standard error and output
that makes sure all the data is read before the process is closed.

The hope is that it may fix some of the timeouts/hangs we see on the
Xamarin.Android build bots as a portion of them hangs in test that use the
code generator.
2019-02-01 15:14:28 +01:00
Alexander Köplinger a1973e5cae Bump api-snapshot 2019-02-01 14:13:38 +01:00
Martin Baulig 2f411750ac "Imperial Red": Bring HttpClient from CoreFx (#11906)
This brings `System.Net.Http` from CoreFx.

It is currently only enabled on Desktop Mac and Linux; Mobile is coming shortly.
2019-02-01 14:09:30 +01:00
Marek Safar af70768885 Merge pull request #12704 from lewurm/arm-ios-epsilon-workaround
[arm/ios] workaround for faulty vcmp.f64 insn
2019-02-01 14:05:06 +01:00
Bernhard Urban cd937eaaa0 Bump corert
Commit list for mono/corert:

* mono/corert@1b7d4a1e4 [Number] make double 0.0 cmp more portable (#30)

Diff: https://github.com/mono/corert/compare/c4ae51646152de0af32b2c85538b6e7317faa7f8...1b7d4a1e4bd79305905338827cc41eb8303364f0
2019-02-01 14:04:45 +01:00
monojenkins ec2b56cc78 [csproj] Update project files 2019-02-01 10:56:46 +01:00
Zoltan Varga 1c1e0b1bad [runtime] Rename most System.Reflection.MonoX classes to RuntimeX for consistency with coreclr. 2019-02-01 10:56:46 +01:00
Thays Grazia 257efc6374 [Tailcall] [arm] [jit] Fix moving tailcall parameters. (#12701)
* When moving parameters for tailcall, first copy the parameters using ARMREG_IP and after that get destination in ARMREG_IP, then it's not necessary the PUSH and POP to SP nor the saved_ip_offset.
Fixes #11489

* Removing unused variable.
2019-02-01 10:01:32 +01:00
Alexis Christoforides 8f5cef9364 [corlib] Import System.IO.File from CoreFX (#12000)
Contributes to #7246
2019-02-01 09:48:09 +01:00
Tanner Gooding 472269a1cf Fixing a GC hole in Number.BigInteger (dotnet/coreclr#22334)
Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 09:25:03 +01:00
Michal Strehovský d5a924a9dd Annotate types moved from S.R.Extensions
Testing how much hate this is going to bring me.

These annotations let ProjectN deal with the fact that we now have two
definitions of System.Environment in the system. This is needed as long
as Project N is stuck on 2.1-level version of the framework.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 09:25:03 +01:00
Stephen Toub 86406319d2 Replace several Nullable<T>.Value with .GetValueOrDefault() (#22297)
The former does extra work that the latter doesn't do, and they're equivalent when we know it contains a value, such as immediately after a HasValue check.

Signed-off-by: dotnet-bot <[email protected]>
2019-02-01 09:09:37 +01:00
monojenkins 65e51b26c3 [bcl] Update BCL Linked Size 2019-02-01 09:09:00 +01:00
Vlad Brezae 6bab31e4c1 [marshal] Optimize clearing of entries for method (#12681)
Fixes dynamic-method-churn.exe timeouts, which was hanging on arm because the finalizer thread was hanging from taking too long to clear these hashtable entries.
2019-01-31 21:48:10 -05:00
Zoltan Varga 7517529b62 [netcore] Add back corlib version check. (#12702) 2019-02-01 01:43:35 +01:00
Zoltan Varga b8b527c7ca [netcore] Ongoing work. (#12697)
* [runtime] Fix icall ordering.

* [netcore] Disable dllmap for netcore for now.

* [netcore] Disable loading some threadpool types which don't exist in netcore.

* [netcore] Disable Mono.Native.
2019-01-31 18:50:39 -05:00
Andrew Au f086f55c17 AsyncSteppingFix - Eagerly initialize the AsyncStateMachineBox to avoid expression evaluation in ProjectN async stepping.
[tfs-changeset: 1732745]

Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 21:05:39 +01:00
Michal Strehovský 1139b8e47a Fix ProjectN build breaks (dotnet/corert#6924)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 19:25:56 +01:00
Alexander Köplinger 78d2492ef6 [bcl] Add Mono.CSharp back to xammac profile
It was removed in https://github.com/mono/mono/commit/96af472795496ad32768d113b1cb42a9d3cdcbcf but xammac does need it still.
2019-01-31 18:19:58 +01:00
Zoltan Varga 57fda1a647 [llvmonly] Make direct calls to icalls/icall wrappers. (#12693)
* [runtime] Improve mono_print_ji ().

* [llvmonly] Add a few more preinited got slots. Avoid emitting TLS_TRAMP preinited got slots in llvmonly mode.

* [aot] Simplify the mangled name of icall wrappers.

* [llvmonly] Make direct calls to icalls/icall wrappers in llvmonly+static mode.

* [aot] Disable some dedup logging which is always 0.

* Fix an strstr call.
2019-01-31 11:51:16 -05:00
Bernhard Urban 719117f9d7 [arm/ios] workaround for faulty vcmp.f64 insn
Fixes https://github.com/mono/mono/issues/11965
2019-01-31 17:02:17 +01:00
Alexander Köplinger a2abcc9a2f [System] Skip DefaultValueAttributeTest.Bug_12362() on xammac 4.5 too 2019-01-31 16:57:25 +01:00
Stephen Toub 554ff45da9 Replace Environment.s_macOS with use of PLATFORM_OSX
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 16:38:51 +01:00
Stephen Toub 05956b9db7 Adapt corert to Environment moving from corefx
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 16:38:51 +01:00
Alexis Christoforides ea55c54fe9 [xammac_net_4_5] Use CoreFX System.IO 2019-01-31 13:48:16 +01:00
Zoltan Varga 6ec5e3a4cf [corlib] Fix the linker descriptors for the SRE classes.
Preserve the ModuleBuilder.RuntimeResolve () method using a PreserveDependency attribute.
Remove nonexistent methods.
2019-01-31 13:47:25 +01:00
Marek Safar c7cb61a9a6 Remove GetSystemMaxDBCSCharSize implementation 2019-01-31 08:41:41 +01:00
Marek Safar f3ef35c779 Add managed implementation of GetSystemMaxDBCSCharSize (#22290)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 08:41:41 +01:00
Tanner Gooding 68606a1c30 Reverting "Fixing up the UTF8Formatter and some tests to properly handle -0.0" (#22300)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-31 08:33:33 +01:00
Marek Safar 1b09a26710 Implement Environment 2019-01-30 23:28:37 +01:00
Stephen Toub 8eeffb8628 Switch CoreLib over to using shared Environment from corefx (#22106)
This requires merging/adapting the implementation with EnvironmentAugments (which goes away completely), the shared files, what corert has, etc.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 23:28:37 +01:00
Jonathan Chambers 115c196575 Implement marshaling for generic struct fields (#12660) 2019-01-30 13:57:03 -05:00
Johan Lorensson 1350f7a77a Windows support to abort blocking system calls. (#12654)
* Fix race condtion in socket altertable wait implementation on Windows.

* Add support to abort blocking Windows mono_w32file_read/write methods.
2019-01-30 13:53:44 -05:00
Vlad Brezae 2f92606f1f [tests] Disable oldgen stress on interp (#12682)
[tests] Disable oldgen stress on interp
2019-01-30 12:36:06 -05:00
Vlad Brezae e461679612 [interp] Add support for break on method entry (#12651)
[interp] Add support for break on method entry

When using --break. We need to have a breakpoint set from debugger in mono_break.
2019-01-30 11:36:24 -05:00
Rolf Bjarne Kvinge 29b163f41c Fix leak if mono_assembly_setrootdir is called multiple times. (#12648)
Fix leak if mono_assembly_setrootdir is called multiple times.

Fix leak if mono_assembly_setrootdir is called multiple times by freeing the
previously stored value.




<!--
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
-->
2019-01-30 10:16:01 -05:00
Vlad Brezae efac4c16ed [sgen] Logging for objects kept alive from ephemerons (#12650) 2019-01-30 16:17:08 +02:00
Rolf Bjarne Kvinge c9583047e8 Fix leak if mono_set_config_dir is called multiple times. (#12647)
Fix leak if mono_set_config_dir is called multiple times.

Fix leak if mono_set_config_dir is called multiple times by freeing the
previously stored value.




<!--
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
-->
2019-01-30 09:15:57 -05:00
Michal Strehovský 434ec4110d Fix namespace of the AmbiguousImplementationException (#22291)
Moving to the namespace that was approved in dotnet/corefx#34124.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 13:48:02 +01:00
Jonathan Chambers ea95b18bde Throw ArgumentNullException if null method is passed to delegate constructor via invoke. (#12668)
Throw ArgumentNullException if null method is passed to delegate cons…

…tructor via invoke.

Fixes Unity issue: https://issuetracker.unity3d.com/issues/editor-crashes-with-g-logv-when-entering-play-mode-with-active-flowcanvas-script
2019-01-30 05:06:20 -05:00
monojenkins 3730afd464 [bcl] Update BCL Linked Size 2019-01-30 09:46:03 +01:00
Markus Kitsinger 63e512d133 Add AmbiguousImplementationException (dotnet/coreclr#22280)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:33:07 +01:00
Markus Kitsinger 3850bce0f0 Do not cache error string in SerializationException (dotnet/coreclr#22281)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:33:07 +01:00
Marek Safar 3322b33f0d Remove Mono implementation 2019-01-30 09:30:24 +01:00
Marek Safar 167e79290f Move Marshal::StringTo* methods to shared partition (dotnet/coreclr#22266)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:30:24 +01:00
Tanner Gooding fb1a589aea Fixing several of the HWIntrinsic SoftwareFallback functions to be captureless (#22263)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:30:24 +01:00
Michal Strehovský 3d17e982c1 Recover some of the size lost with AsyncMethodBuilder/Task unification (#6913)
When we unified the implementations of these across all of our runtimes, we lost all size optimizations people have been doing on the Project N side over the past six years.

This restores a bit of the loss. For one sample app with lots of async usage, this removes 2.1 MB of generic instantiations.

There is more we can do, but I can't spend time on that right now. These two things jumped out on me when I was looking at it back in December and were an easy fix I wanted to do for a while.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-30 09:30:24 +01:00
Zoltan Varga 4799e263a9 [aot] Size optimizations. (#12631)
* [gshared] Make mono_method_lookup_or_register_info () static, its only used in mini-generic-shared.c. Simplify callers.

* [aot] Optimize the encoding/decoding of MonoJumpInfoRgctxEntry.

Previously, all entries were associated with a method, but thats only needed for entries which have
is_mrgctx set, the rest can be associated with a class. Also, emit the encoding of methods/classes
only once, then refer to the them using a blob offset.

* [aot] Optimize the encoding of generic contexts by emitting every ginst only once.

* [aot] Add a MONO_AOT_METHOD_FLAG_HAS_PATCHES flag to avoid having to write the number of patches if its 0.

* [aot] Add a preinited got slot for MONO_PATCH_INFO_GC_SAFE_POINT_FLAG, fix the equality test.
2019-01-29 16:10:51 -05:00
Alexander Köplinger af2b7fec45 [utils] Add mono-errno.h to EXTRA_DIST
It was missed in https://github.com/mono/mono/pull/12082
2019-01-29 21:30:15 +01:00
Thays Grazia 4c09d46388 [Wasm][Debugger] Object inspection. (#12655)
* [Wasm][Debugger] Object inspection.

* Changind  indention formatting.
2019-01-29 10:37:08 -05:00
Kenneth Pouncey 51e3be76db [wasm] Wasm Websocket support (#12615)
* [wasm] Fix crash with delegates.

Internally the javascript bridge support uses `System.Delegate` and `System.Delegate.DynamicInvoke` to support delegate callbacks.  The linker, when executed over the assemblies, does not know about this code coverage and will strip out `System.Delegate.DynamicInvoke`.

To fix this:

- Add reference to `System.Delegate.DynamicInvoke` to the `WebAssembly.Bindings` linker xml file so the linker knows not to strip the code.
- Add detailed error messages in case something else goes wrong so the crash is not so cryptic.

* [wasm] WebSocket support initial commit.

- Connect to socket
- Basic Send and Receive support for Text and Binary - Needs work.
- Close socket.

* Add nuget packaging for build tools sdk

* Add Not Implemented Exceptions to the ClientWebSocketOptions implementation.

- The browser websocket specification does not provide for referencing the underlying http parameters.
- KeepAliveInterval - The browser websocket implementation implements the PING/PONG implementation and does not provide a mechanism via the websocket API.

* Remove validattion for keepalive as it is not implemented.

* a couple more Not Implemented Exceptions for WebSocketOptions

* Change to PlatformNotSupportedException.

* ProjectReference instead of assembly.

* Add websockets assembly to sdk build

* Add WebAssembly.Net.Websockets to packager.

- Treat as core for AOT linker.  This should be linked out but the linker but will appear in the loaded assembly list.
- Make sure it is imported as part of the non AOT build.

* Cleanup code.

* Add WebAssembly.Net.WebSockets assemblies to package
2019-01-29 10:35:33 -05:00
Katelyn Gadd 3704221361 Fix pipes not being enabled in all relevant versions of the build profile 2019-01-29 11:41:04 +01:00
Egor Bogatov cd69f587dc [corlib] TimeZoneInfo from corefx (#11500)
Not yet enabled for mobile, build and basic profiles.
Doesn't require ICU dependency, also I created a small PR for dotnet/coreclr to improve TimeZoneInfo.DisplayName on unix: https://github.com/dotnet/coreclr/pull/20728

Part of #7737
2019-01-29 11:34:00 +01:00
Marek Safar 1f4a0965cc Add Marshal ansi conversion to shared partition (dotnet/coreclr#22243)
* Add Marshal ansi conversion to shared partition

* Ignore bestFit/throwOnUnmappableChar on Unix

* Use same assert in StringToAnsiString

* wideCharLen parameter rename

Signed-off-by: dotnet-bot <[email protected]>
2019-01-29 09:15:21 +01:00
Filip Navara 30b930a0fe Add sample from issue #12402. 2019-01-28 23:43:13 +01:00
DasSkelett cd814981ea Take text alignment for LinkLabels into account (#12643)
<!--
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
-->
## Problem
`LinkLabels` ignore the text alignment for rendering the "hitbox" and the text color (= the `LinkArea`), and the focus rectangle. Also every text behind the end of this LinkArea/focus rectangle region is not painted at all.
This becomes visible if `AutoSize = false` and the `Size` is bigger than the text would need,
and if the text alignment is anything different than `TopLeft`.

## Cause
I think this is because the `piece.regions` are only translated regarding the padding, but neglecting the text alignment.

## Solution
Calculate the offset due to alignment and add it to the translation in `LinkLabel.CreateLinkPieces ()`

Fixes #12402 

## One more problem:
~Right now, a very tiny bit at the end of the label is still cut off (see my zipped and attached comparison pictures). Maybe `GetBounds ()` returns a value little bit smaller than it should be.
Can someone help?~

Also, maybe I took the wrong approach to this issue, but I don't know the inner mechanisms of mono.
So feel free to either advise me to change something, or change it yourself(s) :)
2019-01-28 23:30:10 +01:00
Mike Krüger 085ddcccb5 Fixes VS4Mac Issue #6898 (#12432)
https://github.com/mono/monodevelop/issues/6898

Not sure if it's the root of the problem but it surely fixes the dead lock on my machine.
2019-01-28 16:30:40 -05:00
Aleksey Kliger (λgeek) 1ec822976b [cxx] Set CXXLD and CCLD in configure (#12625)
* [cxx] Set CCLD and CXXLD for final linking

Essentialy bypass automake's automatic linker selection based on _SOURCES file
extensions.

The issue:
  1. Right now we need to use the C linker unless we're linking with LLVM which
     needs C++.
  2. Later when we start using C++ in Mono we will still want the C linker,
     because we will use a subset of C++ that doesn't depend on the C++ runtime
     library (because we don't want to break embedders that don't expect us to
     use C++).

So in either case which linker we use is a decision that we want to make
independent of what the file extensions look like.

So we set MONO_CXXLD in configure.  If LLVM is enabled, we use $CXX, otherwise
$CC.

Then in mono/mini/Makefile.am.in we set CCLD and CXXLD to MONO_CXXLD.  So
whatever automake decides we're going to use the linker that we want.

This partly reverts 988f4a2147 which tried
another approach (which turned out not to work).

This should also address https://github.com/mono/mono/issues/12060

Closes https://github.com/mono/mono/issues/12435

* [cxx] Fix link errors if both --enable-llvm and --enable-cxx are on
2019-01-28 16:22:00 -05:00
Ben Adams b4534a0cd2 string.EndsWith use SequenceEqual not SequenceCompareTo (#22207)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-28 09:38:26 +01:00
[email protected] 6c4199d25d Improve BinaryReader.ReadUInt32() perf by 30% when using MemoryStream (#22102)
BinaryReader.ReadInt32() has nice optimization which was missing from the ReadUInt32() version. Now both implementations are aligned.

ReadUInt32 and all the 64 bits types are now 30% to 50% faster than original implementation.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-28 09:38:26 +01:00
Ben Adams d35e06ff3c Shrink Task.Delay when used without cancellation (dotnet/coreclr#22233)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-28 09:38:26 +01:00
Dotnet-GitSync-Bot 3b2c1ca08a Mirror changes from mono/corefx,corert (#12645)
This PR contains mirrored changes from mono/corefx,corert


**Please REBASE this PR when merging**

 cc @jkotas
2019-01-28 09:33:53 +01:00
Marek Safar c40885324e Remove local Timer copy 2019-01-27 22:45:35 +01:00
Stephen Toub 6d13120e7c Remove several uses of VoidTaskResult (dotnet/coreclr#22238)
* Remove defunct netstandard code from ValueTask

* Remove several uses of VoidTaskResult

Currently TrySetResult/Canceled/Exception live on `Task<T>`.  There's no reason `TrySetCanceled` and `TrySetException` need to live there, as they only access state from the base `Task`, and so can be moved down.  `TrySetResult` needs the `TResult`, however in a variety of cases `Task<T>` is used with a `VoidTaskResult`, and for such cases we can just have a parameterless `TrySetResult()` on the base class as well, which can be used any time there is no `TResult` or when `default(TResult)` is the desired result.  This lets us switch several cases where we were using `Task<VoidTaskResult>` to just be `Task`, which saves 8 bytes on the task instance on 64-bit.  It also avoids an Interlocked.Exchange as part of the TrySetResult call.

This primarily affects Task.Delay and the non-generic variants of Task.WhenAll, ValueTask.AsTask(), Task.FromCanceled, and Task.FromException.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-27 22:45:35 +01:00
Filip Navara 0ed3a181c1 Move Timer to shared CoreLib partition. (dotnet/coreclr#22231)
* Move Timer to shared CoreLib partition.

* Move SignalNoCallbacksRunning back to shared code, add static EventWaitHandle.Set.

* Remove AppDomain references from shared Timer code, reshuffle some code out of SetTimer in non-shared code.

* Change m_ prefix to match code style.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-27 22:45:35 +01:00
Dotnet-GitSync-Bot f932a50d51 Mirror changes from mono/coreclr (#12635)
* Move Marshal::ZeroFree* to shared partition (dotnet/coreclr#22230)

* Move Marshal::ZeroFree* to shared partition

* Add managed version of SysStringByteLen

Signed-off-by: dotnet-bot <[email protected]>

* Remove duplicated code
2019-01-27 08:47:05 +01:00
Stephen Toub 6707bed13b Factor WinRT GetFolderPath into static accessible via reflection (#34873)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-26 14:40:18 +01:00
Dotnet-GitSync-Bot 87220f95fc Mirror changes from mono/coreclr (#12629)
* Move more Marshal methods to shared partition (dotnet/coreclr#22205)

* Move more Marshal methods to shared partition

* Implement ThrowExceptionForHR in managed

Signed-off-by: dotnet-bot <[email protected]>

* Remove local copy
2019-01-26 09:24:24 +01:00
monojenkins 39f669c465 [bcl] Update BCL Linked Size 2019-01-26 08:37:15 +01:00
Zoltan Varga ada3f474cc [aot] Print detailed stats only when --aot=stats is used. Avoid emitting 2 copies of preinited got slots in llvmonly mode. (#12614) 2019-01-25 18:52:36 -05:00
Ben Adams ed3649661e Skip rangecheck in string.EndsWith(char) (dotnet/coreclr#22206)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 20:32:21 +01:00
Ben Adams 32ae150897 Use AggressiveOptimization for intrinsics-based SpanHelpers (#22191)
* Use AggressiveOptimization for intrinsics-based SpanHelpers

* Remove from LastIndexOfAny

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 17:37:03 +01:00
Marek Safar 52dce5ed74 Reduce Task's static ctor dependencies (dotnet/coreclr#22172)
* Reduce Task's static ctor dependencies

* Remove defensive check

* Revert "Remove defensive check"

This reverts commit df15ab0350e8f44fc5cbb1a18c5211cd1de11989.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 17:31:31 +01:00
Larry Ewing e9a084b470 Merge pull request #12611 from marek-safar/linker-fixes
Add monolinker binary assets tests
2019-01-25 09:39:51 -06:00
Elliot Prior f5c045a546 Cancel CTS immediately if delay is zero. (dotnet/coreclr#18098)
The intended behaviour on specifying a delay of zero is that the CancellationTokenSource is cancelled immediately - before this change, it would depend on the scheduling of the timer callback which could lead to seeing a non-cancelled token. Now, it marks itself as cancelled immediately, without invoking any callbacks (as this method is called only from within the constructor of the object, before any callbacks could have been registered.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 15:19:59 +01:00
Ben Adams 7fb70b59cc Speedup .SequenceCompareTo(byte, ...) (dotnet/coreclr#22127)
* Speedup .SequenceCompareTo(byte, ...)

* Rename jump location

* Better annotations for clarity

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 14:06:39 +01:00
Katelyn Gadd acaa73b702 Integration and bug fixes to enable use of roslyn compiler server (#12476)
This PR still needs additional cleanup work to be ready to merge but it's getting close enough to be worth running tests and getting code review. The purpose of this PR is to make various bug fixes and infrastructure changes so that it is trivial to use the roslyn compiler server on a clean checkout.

Summary of the changes:
* configure.ac generates some additional variables in config.make that are used to configure the compiler server mode in make. You can then use the compiler server by passing ```ENABLE_COMPILER_SERVER=1``` to make or flipping the switch in config.make.
* config.make has two variables pointing to the compiler server version of roslyn. This lets you use a local build/checkout of roslyn but only when the compiler server is enabled. Once we update in-tree roslyn these vars can default to that. (The in-tree version of csc is not compatible with the compiler server.) The vars are named ```SERVER_CSC_LOCATION``` and ```VBCS_LOCATION```.
* config.make also has a variable that sets the name of the roslyn compiler server pipe. If you're trying to build multiple checkouts in parallel, or build in multiple user accounts, you'll need to use separate pipenames. You'll be able to set this from the command line once I tweak the config file with ```COMPILER_SERVER_PIPENAME=xxx```.
* basic_profile_check attempts to start the compiler server before any builds happen. I put it there because that was the only way I found to get it to always run before mcs builds. I spent a few hours trying to add a separate build target for this, and then gave up because makefiles. (I'd love to get suggestions on a better way to do this) Because it's nontrivial to track compiler server instances across builds, I just spawn a new one every time - this works fine because the compiler server has logic to detect an existing instance.
* I completely rewrote our implementation of Timer and its scheduler, because the existing one was burning an entire core at all times in the compiler server, mostly calling SortedList methods. The new implementation is probably not release-ready, but I focused on keeping it easy to audit and understand because attempts to preserve the existing logic kept breaking. Ideally we can just pull in corefx's timers here, but it looked non-trivial to do that.
* ReaderWriterLockSlim was checking Environment.ProcessorCount every time it was used, which in most configurations will result in a syscall to getpid() and another syscall to check our affinity. This was bottlenecking the compiler server really bad. I changed this to match most other threading code and use PlatformHelper.ProcessorCount instead.
* Our nunit.snk was corrupt (not sure how this happened) so I replaced it with the current nunit.snk from mainline nunit. Thanks to @jaredpar and other roslyn folks for troubleshooting this - it was causing problems for our msbuild infrastructure as well and I never figured that out.

Some work remains before the compiler server is good enough to use by default, which I will probably document here (or in tree? on a wiki?)
2019-01-25 14:05:29 +01:00
Zoltan Varga 124636c036 [jit] Add support for Unsafe intrinsics. (#12605) 2019-01-25 08:04:19 -05:00
Dotnet-GitSync-Bot f76994e0a1 Mirror changes from mono/coreclr,corert (#12612) 2019-01-25 14:01:09 +01:00
Tomasz Jaworski 901ca2bf6d Fix handling invalid Windows proxy config (#12595)
This fixes NullReferenceException that was thrown if:
-
 HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ProxyEnable was set to true (1)
-
 HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\ProxyServer was set to null

Fixes #10030
2019-01-25 11:48:23 +01:00
Zoltan Varga f96d070114 [ci] Add CI_TAGS handling for ccache (#11305) 2019-01-25 11:37:18 +01:00
Zoltan Varga 9b8ff3260b [netcore] Port classes to netcore (#12548) 2019-01-25 09:47:31 +01:00
Marek Safar dcbe42a59c Add monolinker binary assets tests 2019-01-25 00:16:42 +01:00
Filip Navara 5f7db9082e Fix argument checks in ThreadPool.RegisterWaitForSingleObject. (#6887)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 00:07:11 +01:00
Marek Safar 06e109380e Fix the build 2019-01-25 00:00:06 +01:00
Tanner Gooding a184818adf Fixing some issues with the decimal parser/formatter (dotnet/coreclr#22070)
* Fixing the decimal formatting so that -0 prints as 0

* Fixing the decimal parser to consider digits still in the buffer as part of the zero/non-zero tail check

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 00:00:06 +01:00
Marek Safar ea13736f5c Move TaskContinuation to shared partition (dotnet/coreclr#22167)
* Move TaskContinuation to shared partition

* Remove TASK_STATE_THREAD_WAS_ABORTED from Task

* Use already existing ThrowAsync

Signed-off-by: dotnet-bot <[email protected]>
2019-01-25 00:00:06 +01:00
Michal Strehovský c313fc50ff Fix UWP VirtualAlloc import (dotnet/corert#6882)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 23:08:38 +01:00
Zoltan Varga af8d01c458 [runtime] Fix #ifdef NETCORE. 2019-01-24 23:07:56 +01:00
Alexander Kyte 56d8b8ec5f Merge pull request #12081 from alexanderkyte/posix_funcs_fix
[runtime] Guard usage of unix functions that aren't posix
2019-01-24 12:53:25 -05:00
Aleksey Kliger (λgeek) c90d1fe6d8 [image] Don't leak old image->name when closing (#12589) 2019-01-24 12:27:33 -05:00
Zoltan Varga afde007137 [wasm] Make the compilation of the empty.cs files quiet. (#12593)
[wasm] Make the compilation of the empty.cs files quiet.
2019-01-24 09:45:59 -05:00
Kenneth Pouncey f50cbd18ac [wasm] Fix AOT test build error message 'Unable to compile method'. (#12594)
* [wasm] Fix AOT test build error message 'Unable to compile method'.

* Remove `--aot-interp` command line option

* Remove a few more options

* add --linker option
2019-01-24 06:17:01 -05:00
Bernhard Urban c8552ac097 [runtime] cleanup around native crash info (#12581)
[runtime] cleanup around native crash info

Contributes to https://github.com/mono/mono/issues/12404
2019-01-24 06:05:44 -05:00
Bernhard Urban f394d7cd8e [spinlock] reduce interations in BCL test and extract it into a stress test
Reduces execution time from about two minutes down to five seconds for SpinLockTests.
2019-01-24 11:17:20 +01:00
Marek Safar 9f16ba6567 Fix the build 2019-01-24 11:15:35 +01:00
Ben Adams c68385b8a6 Speedup SpanHelpers.IndexOf{Any}(byte, ...) (dotnet/coreclr#22118)
* Speedup SpanHelpers.IndexOf(byte)

* 128 * 2 alignment

* Move TrailingZeroCountFallback to common SpanHelpers

So it can be used by other types than byte

* Speedup SpanHelpers.IndexOfAny(byte, ...)

* Indent for support flags

* More helpers, constency in local names/formatting, feedback

* Skip bounds check in software fallback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 11:15:35 +01:00
Marek Safar 973b5c1b0f Move IOCompletionCallback to shared partition (dotnet/corert#6875)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 11:15:35 +01:00
Stephen Toub 677d83b4ab Implement IAsyncDisposable.ConfigureAwait (dotnet/coreclr#22160)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 10:56:26 +01:00
monojenkins 638c927fc1 [bcl] Update BCL Linked Size 2019-01-24 10:50:17 +01:00
Zoltan Varga 74fba1e6d3 [runtime] Avoid calling mono_pe_file_time_date_stamp () for images loaded from memory. (#12587) 2019-01-24 04:27:58 -05:00
Alexander Kyte 1a480b72d3 [runtime] Fix mono_pe_file_map logging (#12588) 2019-01-24 04:27:37 -05:00
Jérôme Laban a95bbcb8e7 Fix lookup for all SourceLink mappings, prefer local file over SourceLink 2019-01-23 21:09:44 -05:00
Zoltan Varga c821964b29 [runtime] Reorganize mono_dl_build_path () a bit, add a new case for netcore.
The netcore native libs are named System.Native.dylib etc. so they don't have the
lib prefix. Add a case for it.
2019-01-23 18:32:35 -05:00
Alexander Kyte 56d6010e59 [runtime] Fix wasm definition of HAVE_UTIME(S) 2019-01-23 18:30:23 -05:00
Marek Safar 76fcb3343d Fix the build 2019-01-24 00:09:19 +01:00
Filip Navara 9fe6dcb374 Move common ThreadPool code to shared CoreLib partition. (#22115)
* Move common ThreadPool code to shared CoreLib partition.

* Move numWorkingThreads counting out of shared code.

* Rename ThreadPoolGlobals.vmTpInitialized to threadPoolInitialized.
Remove exception handling from ThreadPoolWorkQueue.Dispatch.
Remove obsolete code from ThreadPoolWorkQueue.Dispatch.
Rename ThreadPool.EnsureVMInitialized to ThreadPool.EnsureInitialized.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-24 00:09:19 +01:00
Alexander Kyte 6843fff6a5 [runtime] Remove dependency on getpeername 2019-01-23 17:22:26 -05:00
Alexander Kyte a53c038871 [runtime] Add missing checks for HAVE_STRINGS_H 2019-01-23 17:22:26 -05:00
Alexander Kyte e49e6b55d0 [runtime] Remove missing check for HAVE_SYS_PARAM_H 2019-01-23 17:22:26 -05:00
Alexander Kyte 6d9af6db31 [runtime] Add missing checks for HAVE_SYS_RESOURCE_H 2019-01-23 17:22:26 -05:00
Alexander Kyte 79d3407c70 [runtime] Add missing checks for HAVE_NETINET_TCP_H 2019-01-23 17:22:26 -05:00
Alexander Kyte af3112213c [runtime] Remove dependency on atexit 2019-01-23 17:22:25 -05:00
Alexander Kyte 5c1585cfa9 [runtime] Remove dependency on openlog and closelog 2019-01-23 17:22:25 -05:00
Alexander Kyte 510aa8c702 [runtime] Make it easier to define DISABLE_SOCKETS 2019-01-23 17:22:25 -05:00
Alexander Kyte 9905044f66 [runtime] Remove dependency on utimes 2019-01-23 17:22:25 -05:00
Alexander Kyte a3f286c821 [runtime] Add missing HAVE_SYSCONF 2019-01-23 17:22:25 -05:00
Alexander Kyte 8ceec78af2 [runtime] Remove dependency on GetHostName 2019-01-23 17:22:25 -05:00
Alexander Kyte d185d31120 [runtime] Remove dependency on msync 2019-01-23 17:22:25 -05:00
Alexander Kyte 498a57aa9c [runtime] Remove dependency on getdtablesize 2019-01-23 17:22:25 -05:00
Alexander Kyte cd375339e6 [runtime] Remove dependency on lstat 2019-01-23 17:22:25 -05:00
Alexander Kyte 3a5199388d [runtime] Remove build dependency on chmod 2019-01-23 17:22:25 -05:00
Alexander Kyte af0f33f81a [runtime] Remove dependency on makedev 2019-01-23 17:22:24 -05:00
Alexander Kyte 68ad522689 [runtime] Remove dependency on readlink 2019-01-23 17:22:24 -05:00
Martin Baulig e060c5b0f0 [eglib]: Fix memory leak in g_find_program_in_path(). #11615. (#12580) 2019-01-23 16:41:46 -05:00
Alexander Kyte a80d44980c Merge pull request #12082 from alexanderkyte/no_direct_errno
[runtime] Create some indirection for errno setting
2019-01-23 16:28:09 -05:00
Larry Ewing 63cbf6126e Merge pull request #12551 from kjpou1/wasm-aot-link
[wasm] AOT linkage and samples
2019-01-23 15:25:42 -06:00
Jan Kotas 63d2f0e6ec Fix CoreRT build after moving Task.cs to shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:16:07 +01:00
Filip Navara 25ce6d849d Fix possibly unintentional use of bit-wise or operator. (#22152)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:16:07 +01:00
alexk000 3fd3eb5081 Remove variable name duplication (dotnet/coreclr#22155)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:16:07 +01:00
Marek Safar 89940bd801 Remove redundant files 2019-01-23 22:06:53 +01:00
Marek Safar 39b9e2099f Move Task to shared partition (dotnet/coreclr#22105)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Ben Adams 5bb7ab2f7d Remove duplicate requiresSynchronization params attribute (#22143)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Filip Navara d22d97718a Update parameter names in PInvoke signatures to match MSDN documentation.
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Filip Navara ee6597030e Build fixes.
Signed-off-by: dotnet-bot <[email protected]>
2019-01-23 22:06:53 +01:00
Jérôme Laban 133088a437 Update GetScriptSource more async, show exception message. 2019-01-23 15:50:55 -05:00
Zoltan Varga 80bc0069e4 [llvmonly] Move the mono_aot_init_llvm_method family of functions to llvmonly-runtime.c, rename them to mini_llvmonly_init_... for consistency. (#12575)
[llvmonly] Move the mono_aot_init_llvm_method family of functions to llvmonly-runtime.c, rename them to mini_llvmonly_init_... for consistency.
2019-01-23 12:25:53 -05:00
Larry Ewing 8ac757202a Merge pull request #12254 from marek-safar/bcl-fixes
Enables SRE for wasm
2019-01-23 10:24:39 -06:00
Kenneth Pouncey 45ccb2b185 Address review comments 2019-01-23 17:03:50 +01:00
Kenneth Pouncey b6d5809aa2 Update packager to address review comments
- Add `verbose` CL flag to control `--verbose` mode sent to `monolinker` during link phase.

```
  --verbose (set verbose option on link)
        type: bool  default: false
```
2019-01-23 16:21:04 +01:00
Kenneth Pouncey ab95e60634 Remove netstandard from list of core assemblies as it is now implemented in monolinker. 2019-01-23 15:21:53 +01:00
Sebastien Pouliot d9508b8086 [System.Net.Http] Fix CFNetworkHandler when no data is sent
The handler receive an `Open` and the a `Close` event but never a
`DataAvailable` event.

So it _hangs_ if only a `200` status is received (since the headers
are not considered _data_) received from the web server.

This is because some initialization only occurs inside
`HandleHasBytesAvailableEvent` which is now called, on `Close`,
to ensure the initialization is done before completing the request.

This, along with a cancellation check, makes the test case from
https://github.com/xamarin/xamarin-macios/issues/5190 work properly
with this handler.

Fixes https://github.com/xamarin/xamarin-macios/issues/5289
2019-01-23 14:36:20 +01:00
Bijan Tabatabai 7c87bd7c19 [Fix] GetActiveTcpConnections now returns correct state in unix
The values of the enum for the TcpState are different in Unix systems
than in .NET, so a function was added to convert between the two.

Signed-off-by: Bijan Tabatabai <[email protected]>
2019-01-23 14:34:14 +01:00
Maxim Lipnin b56f4d9184 Japanese calendar era change (#12556)
* Support new Japanese calendar eras

* Port Formatting Japanese First Year of Era

* Fix formatting

* Update switches for mobile mode

* Bump corefx
2019-01-23 14:33:00 +01:00
Martin Baulig 22d01c707c [Mono.Security]: Remove some obsolete test tools.
These tools were using the obsolete `Mono.Security.Protocol.Tls` code
(Legacy TLS), which is scheduled for removal.
2019-01-23 14:32:16 +01:00
Kenneth Pouncey 96f2de301a Merge branch 'master' of https://github.com/mono/mono into wasm-aot-link 2019-01-23 14:29:41 +01:00
Kenneth Pouncey 2aeb4afa26 Bump linker (#12560)
* Bump linker

* Bump linker
2019-01-23 08:27:43 -05:00
monojenkins 98c4e0efd7 [csproj] Update project files 2019-01-23 12:55:42 +00:00
Martin Baulig 5c71a7872d [SslStream]: Flatten exceptions in sync SslStream APIs.
The sync APIs `SslStream.AuthenticateAsClient()` and `AuthenticateAsServer()`
should not throw `AggregateException`.

Fixes #9418.
2019-01-23 13:13:25 +01:00
Steve Pfister 26e0b1deec Fixes #12479 - Fixed issue where time lookups on a symlink (GetLastWrite, Creation, … (#12533)
When given a path to a symlink `GetLastWriteTime` returned the time for the actual file.  This PR resolves that.

Fixes https://github.com/mono/mono/issues/12479
2019-01-23 13:05:59 +01:00
Kenneth Pouncey 4a29e830b3 Merge branch 'master' of https://github.com/mono/mono into wasm-aot-link 2019-01-23 11:44:33 +01:00
Marek Safar dc9bc9e0e6 Enables SRE for wasm 2019-01-23 11:17:47 +01:00
Zoltan Varga 8c7ef3c7a3 [jit] Enable generic sharing for empty structures. (#12570)
[jit] Enable generic sharing for empty structures.
2019-01-23 04:35:52 -05:00
Larry Ewing bd063d89ad Merge pull request #12566 from vargaz/dir-dependency
[bcl] Fix the dependencies for the corlib tests.
2019-01-22 19:44:06 -06:00
Larry Ewing d7be84abc4 Merge pull request #12554 from BrzVlad/feature-interp-virtperf
[interp] Improve performance of virtual calls
2019-01-22 18:43:55 -06:00
Vlad Brezae 5b2d3972a0 [utils] Fix potential overflow (#12559)
[utils] Fix potential overflow

When doing array copy of 16+ GB.
2019-01-22 18:45:27 -05:00
Zoltan Varga d41e8dd5eb [bcl] Fix the dependencies for the corlib tests. 2019-01-22 12:44:36 -05:00
Alexander Kyte 7f1619b570 [runtime] Create some indirection for errno setting 2019-01-22 11:51:12 -05:00
Vlad Brezae ad7cb105ec [sgen] Don't trigger concurrent collections if we exceed soft heap limit (#12536)
Concurrent gc (mark / sweep) allows the heap to grow further, which is not what we want if we already exceeded the limit.
2019-01-22 11:13:38 -05:00
Alexander Kyte 6bcd623e7c Merge pull request #12518 from alexanderkyte/merp_thread_hash
[crash] Place hashes into the json file for all threads
2019-01-22 11:07:59 -05:00
Vlad Brezae 7cdde25858 [interp] Fall back to old implementation when calling on proxy
Virtual call optimizations don't handle remoting yet
2019-01-22 16:56:21 +02:00
Vlad Brezae 81330cd5ac [interp] Allocate interface table as part of MonoVTable 2019-01-22 16:56:21 +02:00
Vlad Brezae 42cc325b44 [interp] Use fast virtual invoke code also for interfaces
As with virtual generic calls, when doing an interface call, we need to iterate over all the methods in the hashing slot.
2019-01-22 16:55:46 +02:00
Vlad Brezae 11aca2f939 [interp] Improve performance of generic virtual calls
Different instantiations of generic virtual methods occupy the same slot in the vtable. We probe them using a single linked list, by the same logic of jit's imt trampolines.
2019-01-22 16:55:46 +02:00
Vlad Brezae 2c73aa015b [interp] Improve performance of virtual calls
We allocate a new interp vtable array that we store inside the type's vtable. This array has the same logic as the jit vtable array and it stores InterpMethod pointers. We embed the virtual method slot in the interp instruction stream.
2019-01-22 16:55:46 +02:00
Aleksey Kliger 55d29aa7d4 [netcore] Make Assembly.Load (new AssemblyName (corlib_name + ".dll")) work again
Partly revert a change in https://github.com/mono/mono/pull/12478

CoreCLR treats `Assembly.Load (new AssemblyName ("System.Private.CoreLib.dll"))`
the same as `Assembly.Load (new AssemblyName ("System.Private.CoreLib"))`  (and
.NET Framework behaves likewise with "mscorlib.dll").
2019-01-22 15:43:11 +01:00
Alexander Kyte 470354fa81 [crash] Test and fix stability of native crash pipeline(s) (#12125)
* [runtime] Make infrastructure for merp tests

* [runtime] Fix dumping when crash happens without sigctx

* [runtime] Disable crashy (886/1000 runs) stacktrace walker

* [crash] Remove usage of allocating build/os info functions

* [crash] Remove often-crashing g_free on native crash path

* [crash] Add crash_reporter checked build

We add a checked build mode that asserts when mono mallocs inside of
the crash reporter. It makes risky allocations into assertions. It's
useful for automated testing because the double-abort often represents
itself as an indefinite hang. If it happens before the thread dumping
supervisor process is started, or after it ends, the crash reporter
hangs.

* [crash] Remove reliance on nested SIGABRT/double-fault (broken on OSX)

* [crash] Fix top-level handling of double faults/assertions

* [runtime] Make fatal unwinding errors return into handled error paths

* [crash] Change dumper logging for better info

* [runtime] Fix handling of segfault on sgen thread

Threads without domains that get segfaults will end up in
this handler. It's not safe to call this function with a NULL domain.

See crash below:

```
* thread #1, name = 'tid_307', queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=2, address=0x10eff40f8)
  * frame #0: 0x000000010e1510d9 mono-sgen`mono_threads_summarize_execute(ctx=0x0000000000000000, out=0x0000001000000000, hashes=0x0000100000100000, silent=4096, mem="", provided_size=2199023296512) at threads.c:6414
    frame #1: 0x000000010e152092 mono-sgen`mono_threads_summarize(ctx=0x000000010effda00, out=0x000000010effdba0, hashes=0x000000010effdb90, silent=0, signal_handler_controller=1, mem=0x0000000000000000, provided_size=0) at threads.c:6508
    frame #2: 0x000000010df7c69f mono-sgen`dump_native_stacktrace(signal="SIGSEGV", ctx=0x000000010effef48) at mini-posix.c:1026
    frame #3: 0x000000010df7c37f mono-sgen`mono_dump_native_crash_info(signal="SIGSEGV", ctx=0x000000010effef48, info=0x000000010effeee0) at mini-posix.c:1147
    frame #4: 0x000000010de720a9 mono-sgen`mono_handle_native_crash(signal="SIGSEGV", ctx=0x000000010effef48, info=0x000000010effeee0) at mini-exceptions.c:3227
    frame #5: 0x000000010dd6ac0d mono-sgen`mono_sigsegv_signal_handler_debug(_dummy=11, _info=0x000000010effeee0, context=0x000000010effef48, debug_fault_addr=0xffffffffffffffff) at mini-runtime.c:3574
    frame #6: 0x000000010dd6a8d3 mono-sgen`mono_sigsegv_signal_handler(_dummy=11, _info=0x000000010effeee0, context=0x000000010effef48) at mini-runtime.c:3612
    frame #7: 0x00007fff73dbdf5a libsystem_platform.dylib`_sigtramp + 26
    frame #8: 0x0000000110bb81c1
    frame #9: 0x000000011085ffe1
    frame #10: 0x000000010dd6d4f3 mono-sgen`mono_jit_runtime_invoke(method=0x00007faae4f01fe8, obj=0x0000000000000000, params=0x00007ffee1eaa180, exc=0x00007ffee1ea9f08, error=0x00007ffee1eaa250) at mini-runtime.c:3215
    frame #11: 0x000000010e11509d mono-sgen`do_runtime_invoke(method=0x00007faae4f01fe8, obj=0x0000000000000000, params=0x00007ffee1eaa180, exc=0x0000000000000000, error=0x00007ffee1eaa250) at object.c:2977
    frame #12: 0x000000010e10d961 mono-sgen`mono_runtime_invoke_checked(method=0x00007faae4f01fe8, obj=0x0000000000000000, params=0x00007ffee1eaa180, error=0x00007ffee1eaa250) at object.c:3145
    frame #13: 0x000000010e11aa58 mono-sgen`do_exec_main_checked(method=0x00007faae4f01fe8, args=0x000000010f0003e8, error=0x00007ffee1eaa250) at object.c:5042
    frame #14: 0x000000010e118803 mono-sgen`mono_runtime_exec_main_checked(method=0x00007faae4f01fe8, args=0x000000010f0003e8, error=0x00007ffee1eaa250) at object.c:5138
    frame #15: 0x000000010e118856 mono-sgen`mono_runtime_run_main_checked(method=0x00007faae4f01fe8, argc=2, argv=0x00007ffee1eaa760, error=0x00007ffee1eaa250) at object.c:4599
    frame #16: 0x000000010de1db2f mono-sgen`mono_jit_exec_internal(domain=0x00007faae4f00860, assembly=0x00007faae4c02ab0, argc=2, argv=0x00007ffee1eaa760) at driver.c:1298
    frame #17: 0x000000010de1d95d mono-sgen`mono_jit_exec(domain=0x00007faae4f00860, assembly=0x00007faae4c02ab0, argc=2, argv=0x00007ffee1eaa760) at driver.c:1257
    frame #18: 0x000000010de2257f mono-sgen`main_thread_handler(user_data=0x00007ffee1eaa6a0) at driver.c:1375
    frame #19: 0x000000010de20852 mono-sgen`mono_main(argc=3, argv=0x00007ffee1eaa758) at driver.c:2551
    frame #20: 0x000000010dd56d7e mono-sgen`mono_main_with_options(argc=3, argv=0x00007ffee1eaa758) at main.c:50
    frame #21: 0x000000010dd5638d mono-sgen`main(argc=3, argv=0x00007ffee1eaa758) at main.c:406
    frame #22: 0x00007fff73aaf015 libdyld.dylib`start + 1
    frame #23: 0x00007fff73aaf015 libdyld.dylib`start + 1
  thread #2, name = 'SGen worker'
    frame #0: 0x000000010e2afd77 mono-sgen`mono_get_hazardous_pointer(pp=0x0000000000000178, hp=0x000000010ef87618, hazard_index=0) at hazard-pointer.c:208
    frame #1: 0x000000010e0b28e1 mono-sgen`mono_jit_info_table_find_internal(domain=0x0000000000000000, addr=0x00007fff73bffa16, try_aot=1, allow_trampolines=1) at jit-info.c:304
    frame #2: 0x000000010dd6aa5f mono-sgen`mono_sigsegv_signal_handler_debug(_dummy=11, _info=0x000070000fb81c58, context=0x000070000fb81cc0, debug_fault_addr=0x000000010e28fb20) at mini-runtime.c:3540
    frame #3: 0x000000010dd6a8d3 mono-sgen`mono_sigsegv_signal_handler(_dummy=11, _info=0x000070000fb81c58, context=0x000070000fb81cc0) at mini-runtime.c:3612
    frame #4: 0x00007fff73dbdf5a libsystem_platform.dylib`_sigtramp + 26
    frame #5: 0x00007fff73bffa17 libsystem_kernel.dylib`__psynch_cvwait + 11
    frame #6: 0x00007fff73dc8589 libsystem_pthread.dylib`_pthread_cond_wait + 732
    frame #7: 0x000000010e28d76d mono-sgen`mono_os_cond_wait(cond=0x000000010e44c9d8, mutex=0x000000010e44c998) at mono-os-mutex.h:168
    frame #8: 0x000000010e28df4f mono-sgen`get_work(worker_index=0, work_context=0x000070000fb81ee0, do_idle=0x000070000fb81ed4, job=0x000070000fb81ec8) at sgen-thread-pool.c:165
    frame #9: 0x000000010e28d2cb mono-sgen`thread_func(data=0x0000000000000000) at sgen-thread-pool.c:196
    frame #10: 0x00007fff73dc7661 libsystem_pthread.dylib`_pthread_body + 340
    frame #11: 0x00007fff73dc750d libsystem_pthread.dylib`_pthread_start + 377
    frame #12: 0x00007fff73dc6bf9 libsystem_pthread.dylib`thread_start + 13
  thread #3, name = 'Finalizer'
    frame #0: 0x00007fff73bf6246 libsystem_kernel.dylib`semaphore_wait_trap + 10
    frame #1: 0x000000010e1d9c0a mono-sgen`mono_os_sem_wait(sem=0x000000010e43e400, flags=MONO_SEM_FLAGS_ALERTABLE) at mono-os-semaphore.h:84
    frame #2: 0x000000010e1d832d mono-sgen`mono_coop_sem_wait(sem=0x000000010e43e400, flags=MONO_SEM_FLAGS_ALERTABLE) at mono-coop-semaphore.h:41
    frame #3: 0x000000010e1da787 mono-sgen`finalizer_thread(unused=0x0000000000000000) at gc.c:920
    frame #4: 0x000000010e152919 mono-sgen`start_wrapper_internal(start_info=0x0000000000000000, stack_ptr=0x000070000fd85000) at threads.c:1178
    frame #5: 0x000000010e1525b6 mono-sgen`start_wrapper(data=0x00007faae4f31bd0) at threads.c:1238
    frame #6: 0x00007fff73dc7661 libsystem_pthread.dylib`_pthread_body + 340
    frame #7: 0x00007fff73dc750d libsystem_pthread.dylib`_pthread_start + 377
    frame #8: 0x00007fff73dc6bf9 libsystem_pthread.dylib`thread_start + 13
  thread #4
    frame #0: 0x00007fff73c0028a libsystem_kernel.dylib`__workq_kernreturn + 10
    frame #1: 0x00007fff73dc7009 libsystem_pthread.dylib`_pthread_wqthread + 1035
    frame #2: 0x00007fff73dc6be9 libsystem_pthread.dylib`start_wqthread + 13
(lldb)
```

* [crash] Add signal-safe mmap/file "allocator"

* [crash] Remove use of static memory from dumper

* [runtime] Reduce print buffer size for lockless printer.

Each frame that prints ends up increased by the size of buff.
In practice, clang often fails to deduplicate some of these buffers,
leading to 30k-big stackframes.

It was noticed by a series of hard-to-diagnose segfaults on stacks that
looked otherwise fine during the crash reporting stress test.

This change fixes this, making stacks a 1/10th of the size. It doesn't
seem to break the crash reporter messages anywhere (may need to shrink
other "max name length" fields), and it's not mission-critical anywhere
else.

* [crash] Use async-safe file memory for dumper internals

* [crash] Add memory barriers around merp configuration

* [crash] Use signal-safe printers on all native crash paths

* [crash] Move gdb/lldb lookup to startup

* [runtime] Move MOSTLY_ASYNC_SAFE_FPRINTF to eglib

* [runtime] Fix all callsites of MOSTLY_ASYNC_SAFE_PRINTF

* [runtime] Fix all callsites of MOSTLY_ASYNC_SAFE_FPRINTF

* [crash] Switch to signal-safe exit function

* [crash] Make dumper enum in managed

* [runtime] Add more information to managed frame

* [crash] Make async_safe printers inlined

* [runtime] Move basic pe_file functionality into proclib

* [crash] Fix handling of thread attributes
2019-01-22 09:09:22 -05:00
Alexander Kyte f4d059f903 [runtime] Remove two missing tests from monodroid+aot excludes 2019-01-22 14:08:03 +01:00
Marek Safar e1d3838af6 Fix the build 2019-01-22 13:40:28 +01:00
Filip Navara dd90410129 Move MemoryFailPoint to shared CoreLib partition (dotnet/coreclr#22104)
* Move MemoryFailPoint to shared CoreLib partition.

* Split MemoryFailPoint into Unix and Windows versions.

* Replace MemoryFailPoint.GetMemorySettings FCall with GC.GetSegmentSize to make sharing with CoreRT easier.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-22 13:40:28 +01:00
Zoltan Varga 4e3264f975 [runtime] Move some internal methods and icalls from MethodBase to RuntimeMethodInfo to ease netcore integration. 2019-01-22 13:30:09 +01:00
Jan Kotas b4012bae49 Fix CoreRT build breaks
Signed-off-by: dotnet-bot <[email protected]>
2019-01-22 12:22:10 +01:00
Marek Safar a61fe27946 Fix the build 2019-01-22 10:14:37 +01:00
Marek Safar 5f59e8f9a3 Move TplEtwProvider to shared partition (dotnet/coreclr#22120)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-22 10:14:37 +01:00
Kenneth Pouncey ef5e58587e Remove link-mode=None
- Address reviewer comments
2019-01-22 10:08:21 +01:00
Martin Baulig a7cfa881fb [System]: Fix race condition in SystemDependencyProvider.Initialize(). #12538. (#12541) 2019-01-22 09:14:56 +01:00
Kenneth Pouncey 402859587e Update README.md 2019-01-22 07:45:58 +01:00
Kenneth Pouncey bc39d7fcd9 Update README.md 2019-01-22 07:42:14 +01:00
Kenneth Pouncey 434d70053d Update README.md
Fix link
2019-01-22 07:39:46 +01:00
Kenneth Pouncey 9d82a07db3 [wasm] Update documentation 2019-01-22 07:21:19 +01:00
Kenneth Pouncey 4173fb24f2 [wasm] Modify packager linkage for AOT'd code.
- Add new experimental command line option

   - --link-mode=None|SdkOnly|Full        Set the link type used for AOT. (EXPERIMENTAL)
   - `None` no linking.
   - `SdkOnly` only link the Core libraries.
   - `Full` link Core and User assemblies. **(default)**

- Add the Facades directory to the resolve paths.
- Treat netstandard, WebAssembly.Bindings and WebAssembly.Net.Http as core libraries.  `monolinker.exe` does not see `netstandard` as a core library.
2019-01-22 07:20:45 +01:00
Kenneth Pouncey d2635afea2 [wasm] Fix a few issues that crop up from time to time. Mostly affects running in an AOT'd application. 2019-01-22 06:36:27 +01:00
Kenneth Pouncey 045eed6107 [wasm] Fix a problem with void methods that are invoked.
- The problem stems from void methods returning a corrupted MonoObject when the method that is invoked is marked as `void`.
- Internally the cwrap'd invoke method is defined as returning a `number` which internally will return the result from `mono_wasm_invoke_method` of the driver.  In the case of `void` methods this may contain invalid address reference causing a memory access crash if referenced.
2019-01-22 06:35:11 +01:00
Kenneth Pouncey 5cfcd27534 [wasm] Add two new AOT'd samples targets 2019-01-22 06:25:55 +01:00
Jérôme Laban 920074b55f Fix invalid csharp_space_between_method_declaration_name_and_open_parenthesis 2019-01-21 17:52:12 -05:00
Jérôme Laban 90234bd386 Reformat additions based on editor config file 2019-01-21 17:47:55 -05:00
Jérôme Laban bba2b18202 Adjust editor config based on https://www.mono-project.com/community/contributing/coding-guidelines/#style-guidelines 2019-01-21 17:47:09 -05:00
Martin Baulig 13540da80b [System]: Correctly dispose inner stream in WebResponseStream. #11928. (#12459) 2019-01-21 23:24:57 +01:00
Stephen Toub bce478353a Avoid intermediate strings in some StringBuilder formatting (#22111)
* Avoid intermediate strings in some StringBuilder formatting

Several appends to string builders are first creating strings and then appending those strings, and they're not using the existing Append(primitive) overloads because they want to customize the format string or provider as part of appending the value.  This fixes a few of those cases, using another internal AppendSpanFormattable overload on StringBuilder.

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-21 22:36:43 +01:00
Bernhard Urban aa0f15fdca [tvOS] cleanup defines for tvOS (#12539)
Fixes https://github.com/mono/mono/issues/11697
2019-01-21 21:36:06 +01:00
Alexis Christoforides cbfd736864 [configure] Small fix in sigaltstack() checking on cross-compiler case (#12365) 2019-01-21 21:35:49 +01:00
Thays Grazia 5078e23d75 [Debugger] Checking server version before call elapsed_time (#12511)
* The version of the server and client should be bumped to call the elapsed_time.

* Removing extra {

* Calling correctly.

* This should be checked in ThreadMirror.ElapsedTime instead using vm.CheckProtocolVersion (), so calling the public method will fail.
2019-01-21 15:28:12 -05:00
Jérôme Laban 4461e1e6a1 Adjust formatting, add .editorconfig 2019-01-21 12:50:50 -05:00
Jérôme Laban 78ef51b90a Add support for full document path
- Show the full file name in chrome source browser
- Fix support for duplicate file names in different paths
2019-01-21 11:26:12 -05:00
Jérôme Laban 4d4dc12932 Fix "Collection was modified" for pending operations 2019-01-21 11:26:12 -05:00
Jérôme Laban 91909b2b24 Fix NRE for unknown method token for some generated methods 2019-01-21 11:26:12 -05:00
Jérôme Laban 6160337c0f Fixed support for local urls 2019-01-21 11:26:12 -05:00
Jérôme Laban 49fddf283f Add support for mono pdbs, sourcelink 2019-01-21 11:26:12 -05:00
Marek Safar 6fee0c0ad8 [build] Fix netcore build (#12526)
* [build] Fix netcore build

* Fix Mono env parsing for netcore and reduce Task dependencies

* Fix the build
2019-01-21 16:26:51 +01:00
Zoltan Varga 86bae56326 [runtime] Make -Wreturn-type into an error. (#9915) 2019-01-21 08:57:57 -05:00
Zoltan Varga 32e5af52d9 [wasm] Add a --il-strip option to strip IL code from assemblies in AOT mode. (#12529) 2019-01-21 08:41:12 -05:00
Romain Marcadier-Muller 7cd9e0314d [signcode.exe] Allow use of new hash algorithm (#11999)
Enable SHA256, SHA384 and SHA512 hash algorithms to be used for
Authenticode signatures. This enables producing digital signatures that
are trustworthy using the `mono` tooling.

Fixes #7517
2019-01-21 08:29:45 -05:00
Jay Krell 32aa0ad724 [configure] Silently automatically disable Boehm on x86_64-mingw. (#12274) 2019-01-21 08:28:38 -05:00
Zoltan Varga 78be74cc6b [llvmonly] Mixed mode fixes (#12521)
* [llvmonly] Fix dynamic delegate creation in mixed mode.

* [llvmonly] Fix support for virtual calls in mixed mode. Handle calls which end up being not virtual, and add wrappers
for virtual call signatures too.

* [llvmonly] Disable calling aot-ed synchronized methods from the interpreter, it hits an assert in mono_jit_compile_method_jit_only ().
2019-01-21 07:44:47 -05:00
Kenneth Pouncey 18bd1f434d Add hello.exe build target to make file so aot-sample runs. (#12534) 2019-01-21 13:33:54 +01:00
Zoltan Varga 7318005f0c [wasm] Distribute wasm_tools. (#12532) 2019-01-21 07:28:08 -05:00
Marek Safar 65b441964e Move Task factory type to shared partition (dotnet/coreclr#22089)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-21 12:08:53 +01:00
Bernhard Urban 8730101b3c [ios] enable llvm for watch64_32 runtime (#12497)
I lost that change during upstreaming 🙁
2019-01-21 11:12:02 +01:00
Zoltan Varga 99944c65c5 [wasm] Add support for linking out unused icalls in interpreter and aot+interp mode using a new --link-icalls option. (#12512)
* [wasm] Add a 'wasm-tuner' helper tool which is ran during the app build process.
Currently it only supports one option: --gen-icall-table which generates a linked
icall table based on a linked mscorlib.dll.

* [wasm] Add support for linking out unused icalls in interpreter and aot+interp mode using a new --link-icalls option.

This involves the following steps:
- mono --print-icall-table > icall-table.json
- tuner.exe --gen-icall-table icall-table.json linker-out/mscorlib.dll > icall-table.h
- link icall-table.h into the final executable.

The downside is that this requires compiling a new mono.wasm even in interpreter mode.

* Update README.

* Fix thisdir.

* [csproj] Update project files
2019-01-20 22:34:14 -05:00
Ben Adams 82b940f0e0 Use List<T>.ToArray() in places (dotnet/coreclr#22101)
* Use ReadOnlySpan.ToArray in places

* Use List.ToArray

* Don't take .Length in to local and use as loop condition

Signed-off-by: dotnet-bot <[email protected]>
2019-01-21 01:13:34 +01:00
Jan Kotas 4833a124da Cleanup array related FCalls (dotnet/coreclr#22097)
* Cleanup Array FCalls

* Disable outdated CoreFX tests

https://github.com/dotnet/corefx/pull/34700

Signed-off-by: dotnet-bot <[email protected]>
2019-01-20 17:37:51 +01:00
Jan Kotas 698e3cb786 Fix CoreCLR build for changes in shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-20 09:24:44 +01:00
Jan Kotas 3505ee705e Fix build for ProjectN/WinRTInterop Delete superfluous AsyncCausalityTracer arguments
Signed-off-by: dotnet-bot <[email protected]>
2019-01-19 20:39:48 +01:00
Marek Safar 091f7c3fc8 Fix build
Signed-off-by: dotnet-bot <[email protected]>
2019-01-19 20:39:48 +01:00
Miguel de Icaza 917d219d54 [jit] Constant folding for some Math operations on doubles (#9281)
[jit] Constant folding for some Math operations on doubles

This adds support for constant folding of additions and
multiplications of doubles as well as constant folding of Math.Sin,
Math.Cos, Math.Abs and Math.Sqrt.

Inspired by some changes that went into RyuJit:

https://github.com/AndreyAkinshin/aakinshin.net/blob/master/web/_posts/en/2015/ryujit-rc-and-constant-folding.md
2019-01-19 04:45:39 -05:00
Aleksey Kliger 1a965367e5 [netcore] Add an assembly preload hook by parsing TRUSTED_PLATFORM_ASSEMBLIES property 2019-01-19 09:14:44 +01:00
Aleksey Kliger 2037ad6d09 [assembly] for ENABLE_NETCORE load System.Private.CoreLib from preload hook
in mono_assembly_load_corlib, load "System.Private.CoreLib" using the preload
hook, don't bother with the mono assemblies paths
2019-01-19 09:14:44 +01:00
Aleksey Kliger 8c02942689 [netcore] Don't set up mono_defaults.mono_method_message_class
We don't have a MonoMethodMessage in System.Private.CoreLib yet.  Not sure if we need it.
2019-01-19 09:14:44 +01:00
Aleksey Kliger (λgeek) 7f75e05522 [netcore] Small runtime changes (#12503)
* [configure] --with-core should disable remoting, sre.save and appdomains

* [class-init] with ENABLE_NETCORE System.Array has some constant fields

* [object] for NETCORE don't handle appdomain unload exception specially

Since it doesn't exist in System.Private.CoreLib.dll (it's no netstandard.dll)
2019-01-18 23:34:02 +01:00
Aleksey Kliger (λgeek) 58cb6aa49c [netcore] System.Private.CoreLib changes to match runtime expectations. (#12504)
1. Add classes that the runtime depends on:
   * System.Reflection.RuntimeAssembly and System.Reflection.MonoAssembly
   * System.Mono.MonoDomain and System.Mono.MonoDomainSetup
2. Add fields to some classes so they match what `object-internals.h` expect on the native side.
3. Make a non-`abstract` `System.RuntimeType` stub.
   `System.Type` and `System.RuntimeType` need to have fields that match `object-internals.h` and also the runtime wants to create instances of this type and things go wrong if it's abstract.
2019-01-18 23:33:24 +01:00
Alexander Kyte 34cc1abd19 [crash] Place hashes into the json file for all threads 2019-01-18 17:30:28 -05:00
Alexander Kyte 6e80adbe43 [runtime] Don't try (slow) dlopen on android if it doesn't exist (#12074)
On android, the dlopen call will take around 1ms per AOT module we try to load. By not using dlopen with the existence check, we rely on a much slower dlopen check that happens later. I think they support dlopen of non-resolved names.

This might break a few things if we don't use the full path to dlopen. If it does, we should probably add existence checks at the caller, but this will be an optimization that works everywhere.
2019-01-18 22:45:56 +01:00
Alexander Köplinger ee8e8288a6 [System] Fix test compilation on Android 2019-01-18 22:35:25 +01:00
Marek Safar 076b36d662 Merge pull request #12505 from Dotnet-GitSync-Bot/mirror-merge-10019180
Mirror changes from mono/coreclr
2019-01-18 20:19:04 +01:00
Marek Safar 56848baf6a Fix the build 2019-01-18 20:16:04 +01:00
Alexander Kyte c375ef7370 Merge pull request #12053 from alexanderkyte/fixup_aot_probe
[runtime] Add opt-out for AOT file probing with MONO_AOT_MODE_NONE
2019-01-18 13:28:45 -05:00
Marek Safar 2963d731c3 Move AsyncCausality to shared partition (dotnet/coreclr#22062)
* Move AsyncCausality to shared partition

* Set FeatureAsyncCausalityTracer property

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 18:20:29 +00:00
Aleksey Kliger 278858fe62 [class-init] Allow ghc_slot or finalize_slot == 0
Uninitialized slot values are -1, not 0.

For example GetHashCode could be in slot 0.
2019-01-18 12:26:58 -05:00
Marek Safar 0a86bd4bf7 Fixes build 2019-01-18 16:10:00 +01:00
Stephen Toub 2cd281fae5 Move Environment to shared CoreLib (dotnet/corefx#34654)
Rather than having Environment partially live in corefx and call into an EnvironmentAugments type in CoreLib that in turn calls into an Environment type in CoreLib, we're just moving Environment to live in CoreLib.

To start that, this PR moves Environment and its dependencies from their current locations into the shared CoreLib.  Those changes will mirror over to coreclr.  After that, I'll fix it up to work in CoreLib. And once those changes are built and available back to corefx, I'll update System.Runtime.Extensions to just use the functionality from CoreLib and delete remaining unnecessary code from corefx.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 16:10:00 +01:00
Michal Strehovský 3c0c8adbf8 Enable detection of HW intrinsics (dotnet/corert#6836)
I took the liberty of marking the types containing the hardware intrinsics as [Intrinsic] to avoid doing a name check on everything in the system module. It feels like we should take advantage of this attribute in CoreCLR too.

This doesn't actually enable the support because RyuJIT unconditionally disables HW intrinsics for prejit (both CoreRT and CPAOT are considered prejit). We might want to do something about this on the RyuJIT side to address that (for CPAOT, to be able to pregenerate best code possible ahead of time, assuming a fixed ISA; and for CoreRT without JIT, where the concerns about AVX-SSE penalty don't apply). See conversation in dotnet/coreclr#21603

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 16:10:00 +01:00
Marek Safar 18ca997ac9 Fix defines in TaskAwaiter (dotnet/corert#6846)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 16:10:00 +01:00
Filip Navara 292c674043 Split ContractsBCL into separate classes and move them to shared CoreLib (#22006)
* Split up ContractsBCL into separate classes.

* Move remaining Contract, ContractHelper code to shared partition.

* Split ContractHelper to allow custom debugging experience in CoreRT.

* Simplify ContractHelper.InternalContractFailed.

* Use resource loading code from CoreRT.

* Remove unused parameter.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-18 15:36:44 +01:00
Maxim Lipnin 1c4a35efc3 Add TypeConverter fallback to DefaultValueAttribute (#12412)
Requires https://github.com/mono/corefx/pull/235.

Fixes https://github.com/mono/mono/issues/12362.
2019-01-18 15:22:58 +01:00
Alexander Köplinger 4741e44109 Fix tarball build 2019-01-18 14:37:52 +01:00
Atsushi Eno 72d7b3365b [wasm] fix insufficient csc arguments in sample README (#12493)
There would be newer build instruction with msbuild sdks but so far fix current readme.
2019-01-18 13:20:03 +01:00
Aleksey Kliger 9d697e9c5f Don't hardcode "mscorlib" use MONO_ASSEMLBY_CORLIB_NAME or mono_is_corlib_image
Use the MONO_ASSEMBLY_CORLIB_NAME define instead of hardcoding "mscorlib"
everywhere.  If building for netcore, the define is set to
"System.Private.CoreLib" instead.

In some circumstances, a string comparison against assembly->aname.name is used to
check if something is in corelib.  In cases like that, instead use
`mono_is_corlib_image (assembly->image)` instead.  (This introduces a
dependency on mono_defaults.corlib being correctly initialized, so it's
inappropriate for code that runs very early during startup.  Which I checked as
best I could.)

This should fix every use of literal "mscorlib" in the runtime.

This does _not_ fix every use of literal "mscorlib.dll" in the runtime, partly
because some of those uses are in the Framework-specific codepaths in the
loader and it doesn't necessarily make sense to perturb them.
2019-01-17 21:32:14 -05:00
Marek Safar 2c6ec113ff [System.Private.CoreLib] Initial build pass (#12450)
* [System.Private.CoreLib] Initial build pass

* Add temporary files not officialy converted to allow to build the library

* Formatting changes

* master rebase

* Fixes build

* Doc tests update

* Bump API snapshot submodule
2019-01-17 23:25:23 +01:00
Stephen Toub 09e9ffa65e Clean up a few minor Span-related uses (dotnet/coreclr#22038)
Some unnecessary Span to ReadOnlySpan casts.
Some places where new Span(...).Slice(...) can be replaced with AsSpan(...).
Etc.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 22:45:03 +01:00
Stephen Toub d4d6122008 Avoid allocations in Utf8Formatter.TryFormat(float/double, ...) (#22011)
* Avoid allocations in Utf8Formatter.TryFormat(float/double, ...)

Currently every call to Utf8Formatter.TryFormat for a float or a double allocates two strings, one for the format string and one for the resulting number.   This avoids those in the common case where we can use float/double.TryFormat and format directly into a stack buffer.  Also removes some unsafe code; the performance of StandardFormat.ToString isn't currently worth the extra nanoseconds gained by using unsafe code.

* Delete assert

There's a test that uses unsafe code to cause this to fail and validate that no exception is thrown.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 22:38:25 +01:00
Alexander Kyte b69ae3049e Merge pull request #12058 from alexanderkyte/fixup_aot_paths_host
[runtime] Don't probe aot cache on android
2019-01-17 16:12:42 -05:00
Zoltan Varga 09f3c2b8e1 [llvmonly] Refactor llvmonly runtime support code by moving it to a separate file. (#12436)
* [llvmonly] Move all runtime support code to a new llvmonly-runtime.c file.

* [llvmonly] Make mini_init_delegate () work in mixed mode, it needs to initialize both the interp and the llvmonly related data.

* [llvmonly] Implement EH support in mixed mode.

On interp->native transitions, add a try-catch. On native->interp transitions, rethrow the exception using a c++ throw.

* [llvmonly] Unify function naming, name all llvmonly runtime functions mini_llvmonly_.

* Fix a build failure.

* Fix windows build.

* Fix an aot failure.

* Fix the EH changes.
2019-01-17 13:16:36 -05:00
Marek Safar d864752ea0 Fix AsyncMethodBuilder build on Mono (dotnet/coreclr#22034)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 17:51:24 +01:00
Kenneth Pouncey dd5f9b8659 [wasm] Fix crash with delegates. (#12464)
Internally the javascript bridge support uses `System.Delegate` and `System.Delegate.DynamicInvoke` to support delegate callbacks.  The linker, when executed over the assemblies, does not know about this code coverage and will strip out `System.Delegate.DynamicInvoke`.

To fix this:

- Add reference to `System.Delegate.DynamicInvoke` to the `WebAssembly.Bindings` linker xml file so the linker knows not to strip the code.
- Add detailed error messages in case something else goes wrong so the crash is not so cryptic.
2019-01-17 15:43:24 +01:00
Marius Ungureanuandbaulig 6e28675564 Update mcs/class/System/System.IO.Compression/DeflateStream.cs
Co-Authored-By: baulig <[email protected]>
2019-01-17 15:00:25 +01:00
Martin Baulig 5068c7cc13 [System.IO.Compression]: Correctly handle exceptions in inner stream. #12205.
DeflateStream now correctly handles exceptions thrown by it's inner stream and
rethrows them after returning from native code.
2019-01-17 15:00:25 +01:00
Bernhard Urban 5625d51903 [.gitignore] recently added targetwatch64_32 2019-01-17 14:15:39 +01:00
Filip Navara 90ca7ea980 Fix CoreCLR build of AsyncMethodBuilder.
Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 14:15:13 +01:00
Kirill Osenkov 98bfa5d904 Fix https://github.com/mono/mono/issues/12461.
After .NET 4.5 .NET Framework has changed the System.ComponentModel.Composition ReflectionModelServices.IsExportFactoryImportDefinition to not throw.

Updating this to match the .NET Framework behavior.
2019-01-17 12:05:10 +01:00
Ben Adams 19d3a157f4 Reduce steps for string.Contains(string value) (dotnet/coreclr#22008)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-17 09:28:07 +01:00
Marek Habersack eebe4b5285 [Android,AOT] Support dumping AOT offsets with Android NDK r17+ (#12454)
The latest Android NDK releases no longer ship with per-platform C headers.
Instead they ship with a set of unified headers and require the presence of the
`__ANDROID_API__` macro in order to select the target platform.
The AOT offset dumper doesn't support this new layout and this commit changes
that by adding support for the unified headers (without removing support for the
older NDKs) thus fixing the following error when trying to dump the offsets with
newer NDK:

    Processing triple: aarch64-v8a-linux-android
    Error parsing '[...]/mono/mono/metadata/metadata-cross-helpers.c'
    [...]/mono/mono/metadata/metadata-cross-helpers.c(5,10): fatal: 'stdio.h' file not found
    Error parsing '[...]/mono/mono/mini/mini-cross-helpers.c'
    [...]/mono/mono/mini/mini-cross-helpers.c(7,10): fatal: 'stdio.h' file not found
2019-01-16 23:57:01 +01:00
Bernhard Urban c8b6e6a8ff [arm64_32] use emulate OPs so it works with bitcode compiled code for armv7k (#12443)
[arm64_32] use emulate OPs so it works with bitcode compiled code for armv7k
2019-01-16 14:15:48 -05:00
Filip Navara f83d82c76f Move AsyncMethodBuilder to shared. (dotnet/corert#6832)
* Move AsyncMethodBuilder to shared.

* Bring back PROJECTN.

* #if-out TrackAsyncMethodCompletion for CoreRT.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-16 19:53:03 +01:00
Alexander Kyte 78af5ccc19 [runtime] Don't define build config dir on android (#12056)
* [runtime] Don't define build config dir on android

* [runtime] Don't look for files in unset mono_get_config_dir
2019-01-16 12:32:57 -02:00
Alexander Köplinger 230c2a7103 Add .gitignore for mono/tests/llvmonly-mixed 2019-01-16 15:02:53 +01:00
Marek Safar c797248624 [build] Add dotnet launcher bridge to the runtime (#12416)
Initial pass on settings this up (it works but using system Mono assemblies only)

Naming nitpicks are welcomed ;-)
2019-01-16 14:39:23 +01:00
monojenkins 6fabd0fbb7 [bcl] Update BCL Linked Size 2019-01-16 14:35:05 +01:00
Alexander Köplinger a7cf1beb8a Revert "Improve github issue template"
It's actually on purpose so we don't get annoying task progress indicators in the issues list.
2019-01-16 14:21:06 +01:00
Alexander Köplinger 6c2ab0edff Improve github issue template 2019-01-16 14:07:46 +01:00
Kenneth Pouncey 0c4d525eb8 [wasm] Build target fixes (#12418)
- Add linker xml descriptor to WebAssembly.Bindings and WebAssembly.Net.Http
   - The XML linker descriptor will keep the full assembly for these assemblies during link.

- Fix Link Assemblies command line.
   - Miscellaneous fixes for how the assemblies are linked whether they are framework or facades.
   - Add the Facades directory to the resolve paths.
2019-01-16 11:40:37 +01:00
Jan Kotas ed6041b7cf String -> string
Signed-off-by: dotnet-bot <[email protected]>
2019-01-16 09:52:55 +01:00
Marek Safar c404a499ad Move more COM exceptions to shared partition (dotnet/corert#6829)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-16 09:46:53 +01:00
Zoltan Varga 4d57a5786a [wasm] Linker changes. (#12433)
* [wasm] Add support for v8 style options to the packager, i.e. --option/--no-option.

Add a --linker option to turn on linking in interpreter mode.

* [wasm] Add a print-table.py helper script to print out the function table of a wasm module.

* [runtime] Add a --print-icall-table option to dump the icall table as json. Usable for linking the icall table.

* [runtime] Pass the method to the icall table lookup function.
2019-01-16 03:36:13 -05:00
Alexis Christoforides b79a9e7383 [fullaotinterp/fullaotinterp_llvm] Use CoreFX System.IO (#12386) 2019-01-16 10:02:00 +02:00
Miguel de Icaza b748dd14a2 [mini] re-enable LLVM for Linux JIT (#12420)
[mini] re-enable LLVM for Linux JIT

This re-enables the Linux JIT as suggested in https://github.com/mono/mono/issues/12030
2019-01-15 20:15:35 -05:00
Zoltan Varga 12e3cf9f5a [arm] Set the LLVM data layout, without it, opt seems to make incorrect optimizations. (#12429)
* [arm] Set the LLVM data layout, without it, opt seems to make incorrect optimizations.

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

* [x86] Set the LLVM data layout.
2019-01-15 18:57:36 -05:00
Calvin Buckley 324d372168 Bump CoreFX for AIX/FileSystemEnumerator fix (#12375) 2019-01-15 19:40:01 +01:00
Jo Shields 33860df038 Merge pull request #12272 from nealef/context
Cater for later glibc use of ucontext
2019-01-15 11:46:47 -05:00
Jonathan Chambers d0e984aca3 Fix reentrant exception handling. (#12342)
Store handled status in local that is passed into
handler rather than a single thread local value
which can be overwritten in case of reentrance.
2019-01-15 16:56:14 +01:00
Johan Lorensson f4c4372901 Merge pull request #12317 from lateralusX/lateralusX/fix-warning-errors-win64-platform
Fix warning and build errors triggered in win64 platform that doesn't define HAVE_CLASSIC_WINAPI_SUPPORT.
2019-01-15 07:38:20 -05:00
Vlad Brezae 39c8e693f8 [interp] Remove unreachable code (#12411)
We throw exception directly from child frame if the transform phase fails.
2019-01-15 12:59:38 +02:00
Thays Grazia 41eb902535 [Debugger] Debugger failure when field content is assigned by an unsafe value (#12394)
* [Debugger] Debugger failure when a method is called in watches and any field of the Class has the type of the field different of the value of the field because the assign was done in an unsafe way like this:
Now the datatypes check in the fields are only executed when it's not inside an invoke method.
_pinnable = Unsafe.As<Pinnable<T>>(array);
A unit test that reproduces the issue was created either.
Fixes #12374
2019-01-15 07:51:16 -02:00
Zoltan Varga 3e3a2f51dd [wasm] Delete an unused CFLAGS assignment. (#12413) 2019-01-15 04:26:36 -05:00
Tarek Mahmoud Sayed dd9265c8f7 Fix TimeSpan parsing (dotnet/coreclr#21968)
* Fix TimeSpan parsing

* Temporary disabling the failed CI tests

Signed-off-by: dotnet-bot <[email protected]>
2019-01-15 08:57:02 +01:00
Aleksey Kliger 67c5a87ace [threads] Use refcounts for coordinating finalization and detaching
Reverts a29ad08d00 (#9914)

The basic problem we want to solve is the following:
  1. All access to InternalThread:state must be protected by the
     InternalThread:synch_cs mutex
  2. We must destroy the mutex when we are done with the thread.
  3. We don't know which happens later - detaching the machine thread or
     finalizing its InternalThread managed object.

The solution is to replace InternalThread:synch_cs by InternalThread:longlived
which is a refcounted struct that holds the synch_cs.  The refcount starts out
at 2 when the thread is attached to the runtime and when we create the managed
InternalThread object that represents it.
Both detaching and finalizing the managed object will decrement the refounct,
and whichever one happens last will be responsible for destroying the mutex.

This addresses https://github.com/mono/mono/issues/11956 which was a race
condition due to the previous attempt to fix this lifetime problem.  The
previous attempt incorrectly used CAS in mono_thread_detach_internal while
continuing to use locking of synch_cs elsewhere. In particular
mono_thread_suspend_all_other_threads could race with
mono_thread_detach_internal: it expects to take the thread lock and test
thread->state and use the thread->suspended event, while detaching deletes
thread->suspended without taking a lock.

As a result we had a concurrency bug: in suspend_all_other_threads it's
possible to see both the old (non-Stopped) value of thread->state and the
new (NULL) value of thread->suspended.  Which leads to crashes.

---

Background - why we don't know if detaching or finalization happens first.

1. InternalThread normally outlives the machine thread. This can happen because
when one thread starts another it can hold a reference to the fresh thread's
Thread object which holds a reference to the InternalThread. So after the
machine thread is done, the older thread can query the state of the younger
Thread object. This is the normal situation.

2. During shutdown we can have the opposite situation: the InternalThread
objects are finalized first (this happens during root domain finalization), but
the machine threads are still running, and they may still return to
start_wrapper_internal and call detach_internal. So in this case we have an
InternalThread whose finalizer ran first and detach will run second.
2019-01-14 19:29:09 -05:00
Marek Safar 00437dc590 [corlib] Add tracking exception for not object based type hierarchies 2019-01-14 20:38:19 +01:00
lateralusX 4e3ec6540d Review feedback and smaller adjustments to HAVE_API_SUPPORT_WIN32_* defines. 2019-01-14 19:09:18 +01:00
Alexander Kyte 21a0053638 [runtime] Fix jemalloc support (#12388) 2019-01-14 14:59:30 -02:00
Alexander Köplinger 1db473d810 Fix tarball build 2019-01-14 17:48:22 +01:00
Alexander Köplinger 311d1952af [bcl] Embed Source Link information (#12403)
Source Link allows IDEs/debuggers to retrieve a source file from a remote location like GitHub when the local file isn't available.

Specification: https://github.com/dotnet/designs/blob/e55c517a1e7f8dc35b092397058029531209d610/accepted/diagnostics/source-link.md

For now we only embed info about mono, cecil, corefx and corert since that covers 99% of what you usually want to debug and doesn't need fancy logic that reads git submodules and figures out their URLs.

Should enable use cases like https://twitter.com/jlaban/status/1084248087802060801
2019-01-14 15:16:31 +01:00
ShonkyCH b2ec37efde Fix cross compile issue introduced in 5.16 (#12267)
Fix cross compile issue introduced in 5.16

Fixes #9951
2019-01-14 05:35:36 -05:00
Thays Grazia 141bec26a5 [Debugger] Fix crash when there is a generic struct with a field that is an enumerator. (#12368)
* [Debugger]  Debugger crashes when inside a class, there is an internal struct, with a field that is an enumerator.
files.myBucket.GetEnumerator().get_Current().Key
Fixes #10735

* [Debugger] Debugger crashes when there is a generic struct with a field that is an enumerator.
Example: files.get_Current().Key
A unit test that reproduces this crash was added too.
Fixes #10735

* Removing the extra space.
2019-01-14 11:16:20 +01:00
Zoltan Varga 749e93c33c [llvmonly] Mixed mode changes. (#12383)
* [wasm] Add support for llvmonly+interp mixed mode.

* Add new --aot-interp and --aot-assemblies= options to packager.exe.
  The former enables mixed mode, the latter specifies the list of assemblies which will be AOTed.
* Set the proper AOT_MODE and link in interp libraries in the driver when mixed mode is enabled.

* [llvmonly] Add beginnings of support for llvmonly+interp mixed mode. Treat cross assembly calls as possible places where execution can transition to the interpreter.

* [llvmonly] Add mixed mode tests.

* [llvmonly] Return NULL from mono_jit_compile_method_with_opt () if a method is not found in mixed mode, the caller needs to handle it.

* Implement interp entry support for delegate invokes.

* Implement interp entry for virtual calls.

* Implement interp entry in virtual delegate calls.

* Implement interp entry for virtual generic calls.

* Add runtime invoke test.

* [llvmonly] Add a mini_llvmonly_load_method () helper function to reduce the amount of duplicated code.

* [llvmonly] Add a mini_llvmonly_load_method_delegate () helper function.

* Fix the checked build.
2019-01-14 05:15:16 -05:00
Zoltan Varga 1291c08c1d [runtime] Revert part of fc5800b30d, it breaks ios, which seems to have AppDomain.Unload (). (#12398) 2019-01-12 10:06:54 -05:00
Zoltan Varga fc5800b30d [runtime] Disable more code on wasm. (#12379)
* [runtime] Add a 'cleanup' --enable-minimal option to disable the shutdown cleanup code on platforms which don't need it. Enable it on wasm.

* [wasm] Disable mdb support in the device runtime.

* [runtime] Disable appdomain creation/unload icalls if DISABLE_APPDOMAINS is set.
2019-01-11 17:53:02 -05:00
Zoltan Varga 9047295678 [runtime] Register the GC alloc icalls during startup instead of on-demand, since create_allocator () might not be called at runtime in llvmonly mode if the generated code directly calls its wrapper. (#12381) 2019-01-11 17:25:30 -05:00
Stephen Toub 73b2c87dee Add missing overrides to SyncTextWriter (dotnet/coreclr#21956)
Several recently added virtuals to TextWriter were missing overrides on SyncTextWriter.

We were missing overrides of the synchronous `Write(ReadOnlySpan<char>)` and `WriteLine(ReadOnlySpan<char>)` overloads.  The impact here is primarily performance, though it'll still be an observable change in corner-case scenarios: rather than using the base implementation which would copy the span to an array and then invoke the properly overridden array-based Write{Line} methods, it'll now just delegate to the wrapped span methods.  So it calls the correct overload now on the wrapped instance, and saves some cost in the process.

We were also missing overrides for the async `WriteLineAsync()`, `WriteAsync(ReadOnlyMemory<char>, CancellationToken)`, WriteLineAsync(ReadOnlyMemory<char>, CancellationToken)` overloads.  Fixing these doesn't change the overload that's invoked on the wrapped writer, but it does cause the calls to become synchronous rather than queue a task that in turn calls the synchronized overload.  Whether the new behavior is better is arguable, but it keeps it consistent with every other XxAsync method on SyncTextWriter, which in my opinion is more important... if we wanted to alter the behavior for all of the XxAsync methods, we should do it for all of them.

Also, in the StringBuilder-based overrides, we were ignoring cancellation.  And in the recently added DisposeAsync, we should follow-suit with the rest of the async APIs and make it synchronous.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-11 23:17:52 +01:00
Zoltan Varga f14c5ca370 [wasm] Don't make aot-dummy.dll an output of the linker. (#12380) 2019-01-11 14:57:59 -05:00
Eberhard Beilharz 7952489bd2 [swf] Fix dispose of panels in StatusBar (#12355)
This change implements disposing of the panels of a status bar.
2019-01-11 13:21:28 +01:00
monojenkins 1e0bb426c7 [csproj] Update project files 2019-01-11 11:55:09 +01:00
Katelyn Gadd cc73cba992 Rearrange sources files to work around limitations of gensources/xtest integration 2019-01-11 11:55:09 +01:00
Katelyn Gadd b6d5b0e093 Disable the named pipe tests on win32 due to OnNativeIOCompleted issue (7500?) 2019-01-11 11:55:09 +01:00
Katelyn Gadd 6d7167f2f6 Ignore enotconn error results from the socket shutdown API 2019-01-11 11:55:09 +01:00
Katelyn Gadd 5834d7acc6 Move UnixDomainSockets pipe test to only run on linux net_4_x since it seems like it basically will only work there 2019-01-11 11:55:09 +01:00
Katelyn Gadd 1199c999ab Disable two test files for issue #12324 2019-01-11 11:55:09 +01:00
Katelyn Gadd c36000e83b Exclude unix domain socket tests from wasm profile 2019-01-11 11:55:09 +01:00
Katelyn Gadd 31a7a3ff29 Split unix build profile sources file out 2019-01-11 11:55:09 +01:00
Katelyn Gadd dd9160a464 Don't throw in pipestream's finalizer. Include named pipe support in the build profile. 2019-01-11 11:55:09 +01:00
Katelyn Gadd c5decd8c09 Throw an argument out of range exception when a pipe name is too long and specify which argument is out of range. Fixes a corefx test. 2019-01-11 11:55:09 +01:00
Katelyn Gadd 71e7273634 Enable named pipe tests 2019-01-11 11:55:09 +01:00
Katelyn Gadd 26b12f68ff Enable geteuid and seteuid so csc compiler server works 2019-01-11 11:55:09 +01:00
Zoltan Varga 141e1e48a5 [wasm] Compile the wasm runtime using optimization. (#12367) 2019-01-11 04:39:11 -05:00
Stephen Toub 4ff1c28c3f Add WithCancellation for async enumerables (dotnet/coreclr#21939)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-11 10:13:43 +01:00
Vlad Brezae 60d34d95c7 [interp] Fix resuming into interp when finally throws exception (#12328)
We might need to adjust the ip in the same fashion when normally resuming to catch handler.

In the example from the testcase, we have these transitions : ... -> interp_frame -> jit -> eh1 -> interp_frame -> eh2. When eh1 unwinds to call the finally clause from interp_frame it also pops all other lmf entries until there. This means that eh2 thinks it was called directly from the interp_frame (as it would happen with the jit), but in this case there are still the jit frames in the middle. Eh2 doesn't know how to resume over the jit frames, it will just set the resume state to the interp_frame and eh1 will do the resuming over the jitted frames, after run_finally returns gracefully. If the exception were to be handled by frames parent to interp_frame and there are also pushed contexts on the lmf stack, then eh2 could both unwind and resume directly there, skipping eh1 and the jitted frames altogether.
2019-01-11 09:44:04 +02:00
Marek Safar d8690f8f83 Move public interface ISymDocumentWriter to shared location (#21931)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-11 08:15:57 +01:00
Alexis Christoforides bae33bb447 Bump corefx 2019-01-10 16:08:48 -05:00
Marek Safar 5ba3db2155 Move COMException to shared partition (dotnet/corert#6803)
* Move COMException to shared partition

* Review feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 22:02:45 +01:00
Marek Safar 56e0b9448b Moves EnvironmentVariableTarget enum to shared partition (#21930)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 19:07:21 +01:00
monojenkins ab184eb52a [csproj] Update project files 2019-01-10 18:09:26 +01:00
monojenkins 753eaf9641 Bump API snapshot submodule 2019-01-10 18:09:26 +01:00
Maxim Lipnin 7e737e7cc4 Fix unrelated build issues 2019-01-10 18:09:26 +01:00
Maxim Lipnin 45fdf3d7f7 Bump corefx 2019-01-10 18:09:26 +01:00
Ben Adams d9389fa2e1 Move restoring ExecutionContext out of generic methods (#21909)
* Move restoring ExecutionContext out of generic methods

* Move one back

Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 17:13:24 +01:00
Alexander Köplinger a707496149 Bump bockbuild 2019-01-10 16:30:35 +01:00
Kenneth Pouncey 1690b225ec [wasm] Cleanup Framework Bindings and HttpMessageHandler code. (#12326)
* Cleanup Framework Bindings and HttpMessageHandler code.

- move to framework folder to match package structure.  Simplifies packager code finding the framework libraries.
- create solution and project files
- split up the `bindings.cs`, now removed, into multiple files and reformat code
- Clean up xml documentation
- generate xml file documentation on build.
- modify make file to build the solution and modify tests to use framework output.
- modify `packager` to use the correct directory structure.
- modify `sdk` build targets.
- modify `package` target to package the correct assemblies along with source projects and solution.

Tested:

- JavaScript shell tests which run in jenkens
- Browser Tests
- AOT build and tests

* Modify projects to be netstandard instead of framework.

- use dotnet instead of msbuild which is not available.
- Modify test builds

* Fix Sdk.props to point to correct Bindings library path

* Fix build dependencies

* Fix AOT build - duplicate assembly key

* Fix package target
2019-01-10 15:53:05 +01:00
Martin Baulig edaa62f3a1 Misc AppleTls / BTLS exception and error check changes. (#12319) 2019-01-10 14:50:15 +01:00
monojenkins 59aa49b441 [bcl] Update BCL Linked Size 2019-01-10 13:37:11 +01:00
Alexander Köplinger a037a97cdf [Mono.Debugger.Soft] Keep existing crash files in Crash() test
Instead of deleting all, only delete the ones created by the test.
2019-01-10 12:28:39 +01:00
Levi Broderick baa8cf7312 Move OperationStatus into shared source (dotnet/coreclr#21912)
This is the first step to moving OperationStatus from corefx into coreclr. It'll be used by the transcoding APIs which live in System.Private.CoreLib.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-10 10:41:03 +01:00
Alexis Christoforides bb84dad457 [corlib] Fix monodroid build to reinclude CoreFX System.IO (#12057)
* [corlib] Fix monodroid build to reinclude CoreFX System.IO

* [corlib] Fix orbis and unreal builds to reinclude CoreFX System.IO

* [Mono.Native] Build on Android

* [csproj] Update project files

* Bump API snapshot submodule
2019-01-09 20:21:56 -05:00
Bernhard Urban ccc88a9971 [interp] use interp_lmf wrapper for interp2native on platforms with wonky sigcontext (#12293)
[interp] use interp_lmf wrapper for interp2native on platforms with wonky sigcontext

On some platforms (e.g. AppleTV) SigContext is available, but isn't as
precise as we would like to have it. For example, it doesn't save
callee-saved registers and thus aren't restored properly.

Unfortunately, this also means we can't use the fastpath for
interp2native, so we disable it on those platforms.


Needs backport to: 2018-08, 2018-10, 2018-12
2019-01-09 17:55:39 -05:00
Thays Grazia cb77514a94 [Debugger] Crash test (#12304)
* Changing the test behavior as discussed with Ludovic, because we already have knowledge about the unreliability of the crash reporter and the test is not about it.
So if in 10 times at least one of them works for now it's good.
Fixes #11385

* Removing extra message.

* Removing the crash log file after the test is finished.
2019-01-09 17:31:32 -02:00
Kenneth Pouncey cb16759b8a [wasm][ci] Re-enable chakra tests (#12332)
Re-enables the chakra tests now that the upstream jsvu issue was fixed.

Fixes https://github.com/mono/mono/issues/12331
2019-01-09 20:20:25 +01:00
Jan Kotas 0a8c290c5b More DispatchWrapper tweaks
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 18:42:49 +01:00
Marek Safar 0f107837c0 Removes PNSE version of DispatchWrapper and keep only single version with ifdef
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 18:42:49 +01:00
Jan Kotas 4114852a8b Delete files moved to shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 18:42:49 +01:00
Aleksey Kliger 59f6251897 [coop] Move mono_threads_is_blocking_transitions_enabled to header
and make inline
2019-01-09 10:43:19 -05:00
Aleksey Kliger 99eeaab909 [coop] Drop support for MONO_ENABLE_BLOCKING_TRANSITION env var
It was never documented and it is not as useful now with a matured hybrid
suspend.

If MONO_ENABLE_BLOCKING_TRANSITION set, and mono is otherwise configured to use
preemptive suspend, the thread state machinery would perform RUNNING->BLOCKING
transitions (ie: MONO_ENTER_GC_SAFE and friends would be more than no-ops), but
still preemptively suspend every thread.  This was useful for testing the
thread transitions separately from the coop suspend details.
2019-01-09 10:43:19 -05:00
Zoltan Varga a19f9d869d Bitcode mixed mode work. (#12312)
* [llvmonly] Avoid generating/loading trampolines in llvmonly+interp mode.

Add a new execution mode MONO_AOT_MODE_LLVMONLY_INTERP and make --llvmonly-interp use that. INTERP_LLVMONLY defaults to the interpreter, while LLVMONLY_INTERP defaults to aot.

* [llvmonly] Save whenever a method has a gsharedvt variable signature into the aot image and use that instead of looking up its MonoJitInfo, which is a perf problem since its done for all methods.

* Add a case to append_mangled_wrapper_subtype ().

* [llvmonly] Move initialization of delegate->method_ptr to mini_init_delegate (), pass a handle to the callback.

* [llvmonly] Allow --regression to work in mixed mode.

* [llvmonly] Set param names for gsharedvt in/out wrappers.

* [llvmonly] Use the dedup mangler for setting method names for gsharedvt in/out wrappers, shorten the names a bit.

* Revert "[llvmonly] Allow --regression to work in mixed mode."

This reverts commit d7838c1ce7dc0e3d7bfc3c7f01214224f561db90.

* Fix c++-isms.
2019-01-09 15:23:58 +01:00
Kenneth Pouncey 1be89d440c [wasm] Fix build target errors (#12314)
- Fix different errors when building via the nuget instead of locally.
- The nuget generated had a different structure so fixed the output generation to work for both local build as well as nuget build.
- Fix problem with the monolinker.exe not being located correctly.
- Move the monolinker.exe to tools directory within nuget.
2019-01-09 15:20:35 +01:00
Alexander Köplinger a947358007 Disable Chakra tests on wasm
https://github.com/mono/mono/issues/12331
2019-01-09 13:55:05 +01:00
Tomas Weinfurt c6b7d04096 fix DateTime overflow on ARM32 (dotnet/coreclr#21902)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 12:47:28 +01:00
Marek Safar 7897436a7e Moves common COM type to shared corelib partition (dotnet/corert#6782)
* Moves common COM type to shared corelib partition

* Moves GetHRForException to PInvokeMarshal

* Add temporary CORECLR ifdef to ArrayWithOffset

* Apply cleanup from CoreCLR

Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 10:01:33 +01:00
Stephen Toub c7785160c0 Expose string.Concat(ReadOnlySpan, ...) (dotnet/coreclr#21882)
* Expose string.Concat(ReadOnlySpan, ...)

* Add String.Empty fast path to string.Concat(ReadOnlySpan, ...)

Signed-off-by: dotnet-bot <[email protected]>
2019-01-09 09:45:59 +01:00
Alexander Köplinger d8c75df45b Fixup wasm build
We need to also purge any changes done by emsdk
2019-01-09 01:57:20 +01:00
Alexander Köplinger 2bb95a4990 [wasm] Fix build when emsdk repo is dirty
We hit the following issue when the upstream repo receives a new commit:

```
16:11:49 error: Your local changes to the following files would be overwritten by merge:
16:11:49     binaryen-tags.txt
16:11:49     emscripten-tags.txt
16:11:49     upstream/lkgr.json
```

To workaround we now clean the emsdk repo before pulling.
2019-01-08 18:40:15 +01:00
lateralusX 4486952c2f Fix build error when doing MSVC build wihtout cygwin not having a config.h. 2019-01-08 15:01:48 +01:00
Martin Baulig 78cca25b44 Move ENABLE_GSS conditional into System; fixes #12263. (#12303)
Should fix #12263.
2019-01-08 14:33:38 +01:00
lateralusX 46a1c80a41 Fix warnings and build errors when bumping Mono on alternative Windows platforms.
Several of the name changes fixes MSVC warnings where local variables
hides global variables using the same name.

Number of adjustments not building on platforms not defining HAVE_CLASSIC_WINAPI_SUPPORT.

Fix a couple of build projects not setting dependencies on build-init.vcxproj.
This could cause races in build order if projects depend on build initialization.

Added support to force external builds to use msbuild even if ninja is present.
2019-01-08 14:06:14 +01:00
Thays Grazia 0b6eff6ed4 [debugger] Fix test ShouldCorrectlyStepOverOnExitFromArgsAfterStepInMethodParameter (#12114)
The problem was in this line:
ss_nested_with_two_args(ss_nested_arg (), ss_nested_arg ());
The first step_into works correctly entering in the ss_nested_arg method, but the second one doesn't work.
The problem was because this flag MONO_SEQ_POINT_FLAG_NONEMPTY_STACK was set, so the debugger don't consider that it was a possible break.
The solution of the issue was create another flag to identify nested calls and ignore the  MONO_SEQ_POINT_FLAG_NONEMPTY_STACK.
2 new tests were added to test other nested calls.
#Fixes 7326
2019-01-08 09:47:04 -02:00
Dan Moseley b9e209fc93 Fix path length 255 (dotnet/coreclr#21838)
* Fix path length 255

* Fix assert

* Dead code

Signed-off-by: dotnet-bot <[email protected]>
2019-01-08 08:40:23 +01:00
Jan Kotas de75ac8c6f CoreRT updates for files moved to shared partition
Signed-off-by: dotnet-bot <[email protected]>
2019-01-08 08:40:23 +01:00
Marek Safar 84d992cfd7 Moves ComTypes to shared partition (dotnet/coreclr#21861)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-08 08:35:32 +01:00
monojenkins 07dc55c8c4 [bcl] Update BCL Linked Size 2019-01-08 08:29:43 +01:00
Zoltan Varga fea1723e40 [wasm] Enable Mono.Native. (#12143)
* [wasm] Add stubs for a few functions needs by System.Native.

* [wasm] Enable Mono.Native.

* Enable Mono.Native in the mono build.
* Link libmono-native.a into the interpreter/aot builds.
* Add a dlopen fallback to driver.c to allow the runtime to look up the pinvoke declarations.

* [wasm] Enable direct pinvokes for AOT, disable the dl fallback in AOT mode, its not needed since the generate code links directly to the Mono.Native symbols.

* [wasm] Disable more corlib tests for wasm.

* [wasm] Enable running corlib tests on CI.

* [wasm] Pass -D_WASM_ to the Mono.Native build.

* Fix line numbers in stack frame tests.

* Revert "[wasm] Enable direct pinvokes for AOT, disable the dl fallback in AOT mode, its not needed since the generate code links directly to the Mono.Native symbols."

This reverts commit 2d2ba5261c6fa0b6c1c110d53f18c4248c11cdff.

Direct pinvokes need more support since it needs to link against objc-libs, btls, etc.

* [csproj] Update project files
2019-01-07 19:00:17 -05:00
Aleksey Kliger (λgeek) 988f4a2147 [mini] Use C++ linker iff building C++ that needs the C++ runtime (#12266)
* [mini] Use C++ linker iff building C++ that needs the C++ runtime

(This has nothing to do with --enable-cxx.  This is about our LLVM .cpp files).

Explicitly set the linker for libmini.  The issue is that the automatic
linker selection (See
https://www.gnu.org/software/automake/manual/html_node/How-the-Linker-is-Chosen.html)
looks at all the _SOURCES for a target, even those that are only
conditionally added, even if the condition is false.  So because we sometimes
build mini-llvm-cpp.cpp we always get the c++ linker.  But that's not what we
want.

The goal is:
 - if there's any C++ code included into mono (either the shared lib or a
   program) that needs the C++ runtime library, ensure that we link using the C++
   linker.  This was already true, we just need to make sure it stays true.
 - if mono is built in such a way that it has no C++ code in it (that needs the
   C++ runtime library), ensure that we link with the C linker and without
   including the C++ runtime library.
   This will address issues like https://github.com/mono/mono/issues/12060

We do this in two steps:

1. We split out all the c++ source code to libmini-cxx.la and include that into
   libmini.la.

   That's enough to force C++ linking if libmini-cxx.la has any code in it.  If
   there's no C++ code (right now that means there's no --enable-llvm or
   --enable-llvm-runtime), we don't add libmini-cxx.la and all the C source in
   libmini links in the normal manner.

2. We have a hack where we sometimes include libmono.a (the static library)
   into the mono executable.  In that case, we could forget about the C++
   linker (which leads to build failures because llvm uses all the C++ runtime
   library stuff that we forgot to link in).

   So we use the "nodist_EXTRA_..._SOURCES=dummy.cpp` hack to make it look like
   the mono executable has C++ source, which in turn forces the use of the C++
   linker.

   The conditional logic here has to match exactly what we do for deciding
   whether to add libmini-cxx.la into libmini.la.  If we do, then force the use
   the C++ linker here.

   It may seem like another option is to use something like
   `mono_boehm_LINK=$(CXXLINK)` to set a target-specific linker.  But this is
   bad, actually, because in that case we will drop the `..._LDFLAGS` and other
   linker flags unless we're very diligent to include all of them.  The
   `nodist_EXTRA_..._SOURCES` hack is more resilient because automake will
   ensure that all the flags are kept.

* [llvm,wasm] Don't add -lstdc++ in llvm_config.mk

Leave it to the linker.

This is needed when building wasm cross compilers for windows which pass
-static-libstdc++ to configure.  As a result we would get duplicate symbols by
linking against a static libstdc++.a and also the export stubs of libstdc++.dll

In mini, link monow using the C++ linker same as with mono by using the nodist_EXTRA_..._SOURCES
trick.

In wasm, pass -static-libstdc++ to CXXFLAGS, not LDFLAGS.  c++ linking picks up
CXXFLAGS anyway, and -static-libstdc++ has no effect on the C linker and it
doesn't affect explicit -lstdc++ flags anyway.
2019-01-07 17:51:31 -02:00
Marek Safar 65a2c8a396 Moves StackTrace to shared partition (dotnet/coreclr#21757)
* Moves StackTrace to shared partition

* Remove obsolete comment

* StackFrame::GetFileName behaves like property, remove SecurityException

* Adjust CoreRT ifdefs, fix names for consistency

Signed-off-by: dotnet-bot <[email protected]>
2019-01-07 18:45:48 +01:00
Bernhard Urban 333ad864c4 [ios] initial watch64_32 support (#11691)
* [ios] initial watch64_32 support

* align iOSSimulatorTemplate with iOSDeviceTemplate
2019-01-07 14:56:42 -02:00
Zoltan Varga 7d746ac405 [aot] Delete the automatically created temporary directory when using --aot=llvm. (#12294) 2019-01-07 11:37:43 -05:00
Jay Krell ad3a9fbba8 [Coop] Convert and cleanup open/create of named mutex/event/semaphore. (#12002)
* [Coop] Convert System.Threading.Semaphore.
Potential handles are avoided through fixed, but error path converting utf16 to utf8 is introduced.

* [Coop] Cleanup System.Threading.Mutex. Replace gchandle pinning with C# fixed.

* Remove two commented out lines that are not likely to materialize.

* [Coop] Cleanup System.Threading.NativeEventCalls. Replace gchandle with C# fixed.

* Don't assume ves_icall_System_Threading_Semaphore_ReleaseSemaphore_internal output is to stack.
2019-01-07 10:51:10 -05:00
Alexis Christoforides 96259e2b30 [tests] Remove an invalid assertion on System.IO.DriveInfo
All fixed drives are not guaranteed to be ready
2019-01-07 08:21:29 -05:00
Kenneth Pouncey 749a0825c3 [wasm] Fix build targets errors
- The "WasmLinkAssemblies" task could not be loaded from the assembly
2019-01-07 10:55:27 +01:00
Zoltan Varga 4d9bba73a2 Bump corefx to pick up wasm build changes. 2019-01-07 10:11:58 +01:00
Jan Kotas 1bd557004e Delete redundant S.R.InteropServices.PInvokeMap and S.R.InteropServices.PInvokeMarshal (#21831)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-07 09:42:38 +01:00
Ben Adams 18c632ed43 Maintain left.Equals(right) order for equality for compat (#21829)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-06 10:11:18 +01:00
Ben Adams 453de54075 (C#7) Use pattern matching is rather than as with null check (#21828)
* Use pattern matching `is` rather than `as` with null check

Signed-off-by: dotnet-bot <[email protected]>
2019-01-06 10:11:18 +01:00
Ben Adams d2fbbb9633 Remove redundant unsafe contexts (dotnet/coreclr#21826)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-06 09:52:56 +01:00
Mikayla Hutchinson 5abcf78484 [Wasm] Fix build targets packaging 2019-01-05 10:33:49 +01:00
Vlad Brezae ec1510e35f [exceptions] Always process self aborts even if we have one pending (#11927)
[exceptions] Always process self aborts even if we have one pending

For example, in the following code, the abort that ends the thread should be the one thrown from the finally block instead of the try block :

```csharp
try {
	Thread.CurrentThread.Abort ();
} finally {
	Thread.CurrentThread.Abort ();
	Console.WriteLine ("Why are you still here ?");
}
```
2019-01-04 19:25:33 -05:00
Jo Shields 0623e93aee Merge pull request #12271 from directhex/fix-configure-on-old-autoconf
Add explicit no-op to RISC-V FPU detection, to fix old Autoconf (RHEL 6)
2019-01-04 16:16:24 -05:00
Ben Adams 4c8bfc6555 Support faster null checks (dotnet/coreclr#21765)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 21:05:29 +01:00
Stephen Toub bef2df9ed6 Add StringExtensions.Concat to fix Microsoft.IO.Redist assembly
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 20:59:20 +01:00
Neale Ferguson ed617f19ca Missing include 2019-01-04 13:36:42 -05:00
Neale Ferguson 5595d6c611 Cater for later glibc use of ucontext 2019-01-04 13:33:14 -05:00
Jo Shields e978b049a7 Add explicit no-op to RISC-V FPU detection, to fix old Autoconf (RHEL 6)
Apparently, on old versions of Autoconf, a AC_TRY_COMPILE block with an
empty action-if-true block, like:
```
        if test x$fpabi = xauto; then
                AC_TRY_COMPILE([], [
                        #ifdef __riscv_float_abi_double
                        #error "double"
                        #endif
                ], [
                ], [
                        fpabi=double
                ])
        fi
```
emits invalid shell code, like:
```
  (exit $ac_status); } && {
         test -z "$ac_c_werror_flag" ||
         test ! -s conftest.err
       } && test -s conftest.$ac_objext; then

else
```

`else` immediately after `then` is not valid.

This construct is fine on newer versions, where `then :` is used, which
does not count as invalid.

Even though we're not building for CentOS 6 RISC-V, the invalid shell
causes the configure script to fail entirely, e.g. https://jenkins.mono-project.com/view/Releases/job/ng-release-generate-rpm-packages/963/execution/node/142/log/

Add a useless action-if-true which won't affect the program flow, but
means we aren't emitting `then else` on old Autoconf.
2019-01-04 12:39:54 -05:00
Marek Habersack 60e1a3a63f [Android] Fix build with NDK r18 (#11016)
Xamarin.Android is looking to switch to using the latest Android NDK, r18.
However, there are a few build issues in Mono and BTLS which need to be
addressed before that happens.

  * BTLS fails to build some ARM assembly sources with NDK r18's clang.
    https://github.com/mono/boringssl/pull/12 fixes this issue

  * BTLS uses obsolete Android cmake toolchain file.
    Add a configure option to set alternative toolchain file.

  * NDK r18 minimu supported API level is 16.
    This commit makes the API level configurable and sets the minimum platform
    to API 16

  * NDK r18 makes changes to declaration of `mmap` which break Mono build.
    Detect NDK version in `mono-compiler.h` and act accordingly (do not
    redeclare `mmap`)

  * NDK r18 doesn't have `cpp` and SDKs build assumes it's present.
    Detect whether `cpp` is present and, if not, use `compiler -E` instead.

  * NDK r18 uses unified headers exclusively and requires __ANDROID_API__ to be
    set in order to present the correct set of native APIs.
    SDKs now define the macro when the `ANDROID_NEW_NDK` Make variable is set to
    anything else than `no`.
2019-01-04 11:58:14 -05:00
Aleksey Kliger (λgeek) 32074d1698 [coop] Add high level suspend policy accessors (#12116)
- mono_threads_suspend_policy_name
- mono_threads_suspend_policy_are_safepoints_enabled
- mono_threads_suspend_policy_is_multiphase_stw_enabled
- mono_threads_suspend_policy_is_blocking_transition_enabled

The normal accessors (mono_threads_are_safepoints_enabled, etc) just apply the
policy acessors to the current policy
2019-01-04 11:36:05 -05:00
Vlad Brezae f562e59d98 [sgen] Fix debug build (#12067) 2019-01-04 12:24:46 -02:00
Kenneth Pouncey 646515fd35 [wasm] Allow creation of JavaScript Objects. (#11970)
- Allow creation of JavaScript objects without resorting to json parsing and creating hooks.
- Small cleanup of the bindings routines.
- Modify WasmHttpMessageHandler to use new routines and take out the hackish calls.
2019-01-04 13:42:07 +01:00
Egor Bogatov 98b7d35110 Undo changes in ConditionalWeakTable.cs (#12261)
* undo cwt ns21

* implement AddOrUpdate
2019-01-04 12:25:00 +01:00
Mikayla Hutchinson 5f890cede3 Add WebAssembly MSBuild targets (#12221) 2019-01-04 11:51:37 +01:00
Bernhard Urban 21d77b319a [amd64] fix --enable-minimal=jit build (#12265) 2019-01-04 09:42:52 +01:00
Stephen Toub e2ecfe2410 Use ValueStringBuilder instead of StringBuilderCache in PathInternal.Windows.cs
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Egor Bogatov 6db483c371 Eliminate some bounds checks in Path (dotnet/coreclr#21721)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Marek Safar 6e11c95a84 Adds portable version of EncodingTable (dotnet/coreclr#21735)
* Adds portable version of EncodingTable

Most of the implementation is extracted from CoreRT

* Use string comparer directly

* Remove no longer used COMNlsInfo

* Adds localization support

* Removes FeatureCoreFxGlobalization configuration

* Remove redudant encodings look up from GetEncoding

* Keep Hashtable for nameToCodePage as it does not lock on read

* Replace locked dictionary lookup with short switch

* Include comment with msbuild task link used to generate the data file

Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Stephen Toub 011610e440 Improve performance of Path.ChangeExtension (dotnet/coreclr#21766)
In the common case where it need to replace a non-empty extension with a non-empty extension, it currently incurs a substring without the original extension prior to then concatenating with the new extension.  This PR avoids that.

(As the Path implementation is in corelib, this uses string.FastAllocateString and then formats into it with a span; if we wanted to avoid that, string.Create could also be used.)

* Add internal String.Concat overloads for spans

* Use span-based string.Concat overloads in several places

Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:29:04 +01:00
Stephen Toub d3747f620b Reduce allocation in Index/Range.ToString (dotnet/coreclr#21755)
* Reduce allocation in Index/Range.ToString

* Address PR feedback

Signed-off-by: dotnet-bot <[email protected]>
2019-01-04 09:16:57 +01:00
Martin Baulig e8f15493be Merge CoreFX with dotnet/release/2.2 (#11913)
* Trying to merge CoreFX with dotnet/release/2.2

* Disable some System.IO tests

* fix wasm build

* fix fse.notsupported

* Bump API snapshot submodule
2019-01-04 09:10:58 +01:00
Alexander Kyte 84276a51f7 [runtime] Enable interpreter to be used with --enable-minimal=jit (#12080)
[runtime] Enable interpreter to be used with --enable-minimal=jit
2019-01-03 15:45:43 -05:00
Aleksey Kliger (λgeek) 3a4b2b4a32 [coop] Make sure suspend_count is positive in suspend request states (#12241)
* Fix bug in pulse transition - the suspend count was lost and incorrectly
  swapped to 0.
* finish_async_suspend transition - add assertions that the suspend count is
  positive. Try to catch incorrect states sooner.

Fixes https://github.com/mono/mono/issues/12235
2019-01-03 11:23:13 -05:00
Vlad Brezae 1b242b8960 [interp] Fix resuming into interp frame during EH (#12092)
[interp] Fix resuming into interp frame during EH

During EH, we can have the same frame twice on the stack, the original one and when invoking clauses in the same frame from EH. When having a resume state, we need to check if we should catch it in the current frame, or the original.

<!--
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
-->
2019-01-03 10:05:57 -05:00
Marek Safar 5b220bf1dc Updates codeowners 2019-01-03 15:17:27 +01:00
Jan Kotas ec9d78627d Cleanup current culture handling in the unmanaged runtime (#21706)
Large portion of the current culture handling in the unmanaged runtime inherited from desktop has been no-op. The nativeInitCultureAccessors QCall that it used to depend on desktop got (almost) never called in CoreCLR.

- Delete resetting of current culture on threadpool threads. It was needed in desktop because of a very tricky flow of current culture between appdomains. It is superseded by the flowing the current culture via AsyncLocal in CoreCLR.
- Comment out fetch of managed current culture for unmanaged resource lookup. It has number of problems that are not easy to fix. We are not localizing the unmanaged runtime currently anyway, so it is ok to just comment it out.
- Fix the rest to call CultureInfo directly without going through Thread.CurrentThread

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 15:06:47 +01:00
Stephen Toub 40ec59d65b Replace string.Format(SR. with SR.Format(SR. (dotnet/coreclr#21763)
We use SR.Format in almost all places where we format resource strings (without a format provider), but there were a few stragglers.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 09:58:07 +01:00
Stephen Toub 61530694c8 Change a couple string.Replace("a", "b") to string.Replace('a', 'b') (#21768)
The latter is functionally the same but less overhead.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 09:58:07 +01:00
Stephen Toub 4e16ade794 Use StringBuilderCache in PathInternal.NormalizeDirectorySeparators (#21760)
When we do need to normalize, we're currently allocating the StringBuilder/char[] for the full path length.  As long as the path length is less than the max cacheable size (360), we'll now use a cached builder.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-03 09:44:24 +01:00
Marek Safar 91ca78d698 Additional ifdef changes which are ES_BUILD_STANDALONE specific for System.Diagnostics.Tracing (#21748)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 23:08:47 +01:00
Stephen Toub c2a5e933bd Replace Array.Copy(src, dst, int) calls with Array.Copy(src, 0, dst, 0, int) (#21756)
The former calls GetLowerBound(0) on both src and dst, which is unnecessary when the arrays are T[] and thus always have a lower bound of 0.

Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 23:08:47 +01:00
Alexander Kyte 227e7119b7 Merge pull request #12126 from alexanderkyte/telemetry_blob
[crash] Support extra merp params
2019-01-02 12:14:35 -05:00
Jay Krell 6a9d38a2cb Change array construction with rank>4 to use not use varargs -- localalloc. (#12213)
* Change array construction with rank>4 to use not use varargs -- localalloc.
This fixes https://github.com/mono/mono/issues/12193.

This is alternative to https://github.com/mono/mono/pull/12200.
They are both pretty good approaches.
12200 uncovered a hash order dependency which should be fixed either way.

* Fix C++.

* Remove unused MONO_ARCH_VARARG_ICALLS and ARCH_VARARG_ICALLS.
2019-01-02 12:12:46 -05:00
Kenneth Pouncey 9f73df9441 [wasm] Add support to find the wasm framework libraries. (#12211) 2019-01-02 12:11:59 -05:00
Zoltan Varga 0e96ba6889 [llvm] Remove the linkonce code, its not used anymore. (#12173) 2019-01-02 12:11:16 -05:00
Jay Krell fc33a23c68 Remove MonoCompile.inlined_method. It is confusing to have so many MonoMethods in MonoCompile: (#12201)
```
typedef struct {
.
.
.
    MonoMethod      *method;
    MonoMethod      *inlined_method; /* the method which is currently inlined */
    MonoMethod      *current_method; /* The method currently processed by method_to_ir () */
    MonoMethod      *method_to_register; /* The method to register in JIT info tables */
} MonoCompile;
```
so at least remove one of them that is not really used.
2019-01-02 12:09:34 -05:00
Jay Krell 9b285bf28a Do not build up indefinite coop handles in loops. (#12206)
* Do not build up indefinite coop handles in loops.

https://jenkins.mono-project.com/job/test-mono-pull-request-acceptance-tests/11767/parsed_console/log.html
ves_icall_System_Threading_WaitHandle_Wait_internal_raw USED 107 handles

* Add const.
2019-01-02 11:45:23 -05:00
Jay Krell d966231f0a [Coop] Convert and consolidate {remoting,cominterop}type_from_handle. (#12178)
* Consolidate identical functions type_from_handle and cominterop_type_from_handle
mostly into mono_type_from_handle.
However keep them separate for registration/patching sake, since
will error if register twice, else need to arrange to register once.

* [Coop] Convert {remoting,cominterop}type_from_handle.

* Fix warning about missing icall declaratons.
2019-01-02 11:38:29 -05:00
Marek Safar 3de77f3c60 Moves Attribute instance bits to shared location (dotnet/corert#6747)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 16:46:39 +01:00
Filip Navara 5eb676ddea Remove dummy globalization implementation. (dotnet/corert#6756)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 16:37:27 +01:00
monojenkins caf22d5f0b [csproj] Update project files 2019-01-02 13:54:08 +01:00
Leonardo Galli 1746f09efe [build] Fixed csproj.tmpl for macos: Conflict in naming of HostPlatform.
macOS was used for checking HostPlatform for OSX, but darwin is what the value was set to. This fixes the solution and csproj files for OSX.
2019-01-02 13:54:08 +01:00
Jan Kotas 8383b2194b AppContext moved to shared partition - CoreRT specific changes
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:13:31 +01:00
Ben Adams 2586365035 strlen to managed code and vectorize (dotnet/coreclr#21729)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:13:31 +01:00
Marek Safar cd079b1cab Tweaks permissions ifdefs in System.Diagnostics.Tracing (#21733)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:13:31 +01:00
Marek Safar 02c1851501 Moves AppContext to shared location (dotnet/coreclr#21734)
Signed-off-by: dotnet-bot <[email protected]>
2019-01-02 10:05:59 +01:00
Jay Krell 496eceef19 Register two separate functions for mono_fconv_u4 and mono_fconv_u8
instead of each function twice.

Elsewhere there is single instancing based on function address
and registering the same function twice breaks things.
2019-01-01 23:38:17 -05:00
Comical DERSKEAL e78eeecb33 Typo fix (#12230)
Typo fix


<!--
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
-->
2019-01-01 16:15:39 -05:00
Jan Kotas 5a784c3cca Delete useless ArgumentNullException message (dotnet/coreclr#21728)
"Object cannot be null" does not add anything over the default "Value cannot be null"

Signed-off-by: dotnet-bot <[email protected]>
2019-01-01 10:01:05 +01:00
Dmitry Kalyanov d933418d23 Fix data race in System.Web.Caching by using appropriate lock level
System.Web.Caching.CacheItemLRU.this[string].get modifies LRU list so it
must be called under write lock. Cache.GetKeyLastChange violates this
constraint by acquiring only a read lock.

Fixes #12218
2018-12-31 15:36:36 -05:00
Marek Safar 326afd6eaf Moves ExceptionDispatchInfo to shared location (dotnet/coreclr#21725)
* Moves ExceptionDispatchInfo to shared location

* Use struct for Exception.DispatchState, avoid TLAs in names, misc cleanup

Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 21:07:53 +01:00
Jan Kotas c624667e2f Add license, keep more of the CriticalHandle logic in the shared file
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:44:45 +01:00
Marek Safar c508d6d3c9 Moves CriticalHandle to shared location
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:44:45 +01:00
Marek Safar c44a67cf03 Readability improvement in MemoryStream (dotnet/coreclr#21710)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:36:04 +01:00
Koundinya Veluri 66fc2bf37f Don't Sleep(1) in some spin-wait loops (dotnet/coreclr#21722)
- In spin-wait loops that are not expected to last too long, Sleep(1) significantly delays threads from completing the operation
- From eliminating Sleep(1) in such spin-wait loops, there can be a tradeoff, better fairness vs worse throughput, because Sleep(1) removes threads from contention and in some cases fewer threads can make faster progress at the cost of delaying the Sleep(1) threads relatively significantly. Eliminating the Sleep(1) in such spin-wait loops seems to be a good tradeoff.

Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:36:04 +01:00
Jan Kotas 3ea344432f Fix CoreRT build breaks
Signed-off-by: dotnet-bot <[email protected]>
2018-12-31 10:36:04 +01:00
Thays Grazia 2a16c76733 [Debugger] Record time it took between steps. (#12217)
* When going to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/testReport/junit/(root)/DebuggerTests/StackTraceInNative/ for example, we have no idea why the underlying process has exited. To figure it out, we need to go to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/parsed_console/log_content.html#WARNING1 and scroll back up to where the test was executed to find out the debuggee process crashed with an assertion.
This was fixed by redirecting the StandardOutput and StandardError of the debuggee process in the Mono.Debugger.Soft test suite.

* [Debugger] Record time it took between steps.
I implemented a new message to avoid breaking the protocol. I used the MonoStopwatch to count the time between the steps, it was already used in the debugger-agent.
Fixes #8460

* Bump API snapshot submodule
2018-12-30 20:46:09 -05:00
Ben Adams 7315fc3d99 Shorter ExecutionContext.Capture (dotnet/coreclr#21707)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-30 19:26:51 +01:00
Marek Safar 081c438508 Moves generic comparers to shared CoreLib (dotnet/coreclr#21649)
* Moves generic comparer to shared CoreLib

* Keep Index/LastIndexOf optimizations in CoreCLR only

* Moved runtime-specific enum helper to runtime-specific partial type

Signed-off-by: dotnet-bot <[email protected]>
2018-12-30 10:55:01 +01:00
Marek Safar a2e68c76cd Moves ThrowHelper to shared location (dotnet/corert#6741)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-30 00:21:46 +01:00
Filip Navara 6900eb750e Move CultureInfo to shared CoreLib (dotnet/coreclr#21672)
* Move thread CurrentCulture and CurrentUICulture variables to CultureInfo.

* Move CultureInfo to shared CoreLib

* Code style fixes for consistency.

* Fold down APPX code into CultureInfo.CurrentCulture/CurrentUICulture.

* Remove unnecessary parentheses around return statements.

* Remove GetCurrentUICultureNoAppX.

Signed-off-by: dotnet-bot <[email protected]>
2018-12-29 22:49:33 +01:00
Egor Bogatov 34619669a5 Replace Interop.ReadDir.cs with Interop.ReadDir.cs from System.IO.FileSystem (#21622)
* Use Interop.ReadDir.cs from FileSystem (corefx)

* Use ArrayPool

* Remove ReadBufferSize (and static cctor)

* use NameBufferSize for 256 const

* Delete ReadDir and SafeDirectoryHandle.Unix.cs

* Introduce GetDirectoryEntryFullPath, remove uint casts

* Refactor EnumerateFilesRecursively

Signed-off-by: dotnet-bot <[email protected]>
2018-12-29 22:49:33 +01:00
Hugh Bellamy bd60819235 Remove dead Guid parsing code (dotnet/coreclr#21123)
* Remove dead checks in Guid parsing

* Minor cleanups in Guid

* Delete unused failureMessageFormatArgument

Signed-off-by: dotnet-bot <[email protected]>
2018-12-29 22:17:48 +01:00
Kenneth Pouncey a113c668a1 Add pupeteer to the browser tests node packages. (#12179)
- This will download the most recent version of headless to use.
- Add junit-reporter to output a tests output file to be used for jenkins CI in the future.
2018-12-28 10:05:51 -05:00
Kenneth Pouncey 07723a4772 [wasm] Update build docs (#12088)
* Update build docs

* Upate aot info
2018-12-28 08:45:32 -05:00
Jan Kotas 2d73d36997 Use common copy of System.Numerics.Hashing.HashHelpers
Signed-off-by: dotnet-bot <[email protected]>
2018-12-28 11:15:34 +01:00
Aleksey Kliger d1a5fa3783 [mini] Always emit safepoints, except WASM
This addresses https://github.com/mono/mono/issues/11765
2018-12-27 12:19:09 -05:00
Aleksey Kliger 0bf473d29c [marshal] Always emit blocking transitions, except WASM 2018-12-27 12:19:09 -05:00
Aleksey Kliger (λgeek) c1587b9f37 Reduce extern "C", in non-public headers. (#12148) 2018-12-27 09:32:57 -05:00
Jay Krell c09dda16ff ICALL_EXPORT reduction. (#12145)
ICALL_EXPORT should not be placed on HANDLES() functions.
Only the auto-generated wrappers need it, and they get it from the macro expansion.
And the explicit function declarations are generally redundant - the macro creates declarations, too.
2018-12-27 09:32:29 -05:00
Filip Navara 8f8289d444 Move Contracts.cs (CoreCLR version) to shared CoreLib and update code to compile. (#6734)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-27 15:18:55 +01:00
Filip Navara d9c30acd8e Move System/Numerics/Hashing to shared CoreLib. (dotnet/corert#6732)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-26 23:04:30 +01:00
Filip Navara d559dc6b66 Move DebugProvider.Windows to shared CoreLib. (dotnet/coreclr#21657)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-24 14:29:23 +01:00
Ben Adams db8add85e6 Use TZCNT and LZCNT for Locate{First|Last}Found{Byte|Char} (#21073)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-24 11:06:37 +01:00
Michal Strehovský 4f456991bc Fix ProjectN regression in ByReference<T> (dotnet/corert#6713)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-24 00:32:27 +01:00
ichensky 92c2fab68e Add optimization in GetHashCode for Int16 and SByte (dotnet/coreclr#21652)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 19:07:03 +01:00
Jan Kotas da25533507 Delete CoreLib.FixupCoreLibName (dotnet/coreclr#21655)
This method doing blind find&replace of "mscorlib" with "System.Private.CoreLib". It is both incorrect (e.g. if the typename happened to contain "mscorlib" string) and inefficient (unnecessary allocations and use of reflection).

Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 19:07:03 +01:00
Marek Safar 08ad82a826 Extracts public IThreadPoolWorkItem interface to shared CoreLib (#21653)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 11:08:56 +01:00
Marek Safar 676f268a9f Moves CoreLib to shared location (dotnet/coreclr#21654)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-23 11:06:13 +01:00
Ben Adams 55ca4eb088 SpanHelpers deal with nullable reference types (dotnet/coreclr#21232)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 21:37:34 +01:00
Jan Kotas 958529643c Move some Task related files to shared CoreLib partition (#21650)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 19:19:00 +01:00
Jan Kotas 6069e0909a Synchronize Task, Awaiter and ThreadPool implementation with CoreCLR (#6706)
Synchronized the code as much as possible with CoreCLR. The one major piece that I have excluded is tracing. I will look into doing that separately.

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Jan Kotas edc045728c CoreRT-specific Object.cs changes - Fix build breaks - Apply same cleanup to all related files
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Jan Kotas d555d5ac7a Cleanup to match conventions
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Marek Safar ddb79c3924 Moves common part of Object to CoreLib shared
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:29:22 +01:00
Dan Moseley e1c1b7ad52 Remove _syncRoot field from collections (dotnet/coreclr#21628)
* SyncRoot

* Temp disable tests

* Disable outdated CoreFX test

* Tidier

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Tanner Gooding fbfe1a8fc2 Ensure that the S.N.Vector methods are marked as [Intrinsic] and that the attribute is respected by the runtime (#21601)
* Updating the SIMD intrinsics to check for the `[Intrinsic]` attribute

* Ensure that the existing Vector/Vector<T> intrinsic methods are marked as such.

* Fixing Vector<T>.DotProduct and Vector.AndNot to be treated as intrinsic

* Fixing `SIMDIntrinsicBitwiseAndNot` to swap the operands for XARCH

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Marek Safar 48fe8a78c3 Moves ByReference to shared CoreLib (dotnet/coreclr#21633)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Fei Peng 44af99b0ab Implement the remaining BMI1/2 intrinsic (dotnet/coreclr#21480)
* Add tests for BMI1/2 intrinsic

* Implement the remaining BMI1/2 intrinsic

* Fix emitDispIns for BMI instruction

Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Fei Peng e13e7eb7a5 Add AggressiveInlining for Vector<T>.op_Multiply (dotnet/coreclr#21587)
Signed-off-by: dotnet-bot <[email protected]>
2018-12-22 11:16:14 +01:00
Thays Grazia e8c0ce7605 When going to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/testReport/junit/(root)/DebuggerTests/StackTraceInNative/ for example, we have no idea why the underlying process has exited. To figure it out, we need to go to https://jenkins.mono-project.com/job/test-mono-pull-request-arm64/8921/parsed_console/log_content.html#WARNING1 and scroll back up to where the test was executed to find out the debuggee process crashed with an assertion. (#12172)
This was fixed by redirecting the StandardOutput and StandardError of the debuggee process in the Mono.Debugger.Soft test suite.
2018-12-21 22:36:05 -02:00
Jay Krell a0b5245c77 [Coop] Mostly convert 30+ JIT icalls (and embedding API). (#11941)
* [Coop] Mostly convert 30+ icalls used via register_icall.
And infrastructure to support that.
The infrastructure is not as ideal as it could be.
In future the C preprocessor wrappers should be marshal-ilgen wrappers,
so the handles are more efficiently created.

Some of the conversion is incomplete and just goes back to raw pointers,
but mostly it is good.

Some of the conversion is by replacing previously manual conversion
with more automatic conversion, but most of it is new.

* Replace `foo_raw` with `foo` and `foo` with `foo_impl` per https://github.com/mono/mono/pull/11941#discussion_r243436712.

* Replace gchandle with no_safepoints in mono_string_builder_to_utf16_impl.
https://github.com/mono/mono/pull/11941#discussion_r243438706
at least the one loop.

* Fix windows build: mono_string_to_utf8str vs. mono_string_to_utf8str_impl.

* Fix boehm ves_icall_string_alloc vs. ves_icall_string_alloc_raw.

* Reduce apparent or actual diff.

* Add link to GitHub issue.

* Fix merge.

* Reduce another apparent but probably not actual diff.

* FIXME missing error

* Reduce diff in comment.

* Reduce diff in comment.
2018-12-21 18:12:37 -05:00
Alexander Kyte c2438b7dc2 [crash] Support extra merp params 2018-12-21 13:30:33 -05:00
Alexander Köplinger c11a3cdd53 Bump bockbuild 2018-12-21 16:47:02 +01:00
Cody Russell 5d4f630037 Bump bockbuild for VSTS #737323 fix to GtkNSView. (#11972) 2018-12-21 16:26:13 +01:00
Manuel de la Pena 5ce08b8433 Minor style changes. 2018-12-21 13:12:53 +01:00
Manuel de la Pena 5c2267c5a7 Fix error while chaging the request :/ 2018-12-21 13:12:53 +01:00
Manuel de la Pena 2bb9a2b39a Small typo. 2018-12-21 13:12:53 +01:00
Manuel de la Pena 4194c31994 No need to close the obc, it can be reused. 2018-12-21 13:12:53 +01:00
Manuel de la Pena a35d921f81 [Network] Fix CVE 2018-8292 on Mac OS X.
This commit ensures that CVE 2018-8292 is fixed by not setting
auto-redirect in the first request done by CFNetwork. CFNetwork has the
same bug, but we can work around it by performing the first request,
checking the response and, if it is a rediret, follow it without the
Authorization headers.
2018-12-21 13:12:53 +01:00
Filip Navara c628f13279 System.Windows.Forms: Fix incorrect layout for table layout nested in flow layout
Fixes issue #8922. The flow layout code specifies `int.MaxValue` as width in `GetPreferredSize` call, which the table layout didn't handle properly and tried to use all the available space.

Relevant WinForms open source code that implements the same behavior:
https://github.com/dotnet/winforms/blob/master/src/System.Windows.Forms/src/System/Windows/Forms/Layout/FlowLayout.cs#L183-L188

https://github.com/dotnet/winforms/blob/master/src/System.Windows.Forms/src/System/Windows/Forms/Layout/TableLayout.cs#L700-L702
2018-12-21 11:58:52 +01:00
PaulBol 7331c5e1d7 [WinForms] Dispose tooltips (#12059)
I noticed that some controls do not dispose tooltips and timers. Depending on the underlying implementation these may use native resources. Therefore I'd suggest to dispose these with the parent control to not rely on the garbage collector to eventually release the resources.

Additionally, in the case of `ToolStrip.cs` `CloseToolTip` would first create the objects before turning them off.
2018-12-21 10:50:12 +01:00
Egor Bogatov 534c98c070 [NS2.1] More types and members (#11944)
* Add NS21 Events to EventListener

* NS21: System.Data.DbProviderFactories

* Add ISOWeek

* some Socket API, etc

* more ns21 members

* Add GC.GetAllocatedBytesForCurrentThread stub

* clean up in icall-def.h

* bump corert

* Bump API snapshot submodule

* [csproj] Update project files
2018-12-21 10:37:22 +01:00
Zoltan Varga 7846f99f35 [jit] Emit a OP_NOT_NULL in MONO_EMIT_NULL_CHECK. (#12078) 2018-12-20 23:57:51 -05:00
Jay Krell 0d6d334bcb [Coop] Convert ves_icall_System_Array_FastCopy. (#11983)
* [Coop] Port ves_icall_System_Array_FastCopy.
  Using MONO_ENTER_NO_SAFEPOINTS / MONO_EXIT_NO_SAFEPOINTS.
2018-12-20 14:15:39 -05:00
Jay Krell fead81a538 [Coop] Convert System.String icalls. (#11991)
* [Coop] Mostly convert System.String icalls. But do not pin due to perf/profiler.

* Use MONO_ENTER_NO_SAFEPOINTS / MONO_EXIT_NO_SAFEPOINTS

* Add FIXME to MONO_HANDLE_RAW (mono_ldstr_metadata_sig ()), looks like a reasonable place to temporarily suspend the coop conversion graph walk.

* Restore MonoObjectHandleOut to mono_handle_assign_raw (was mono_handle_assign).
2018-12-20 14:13:10 -05:00
Alexander Köplinger ddf6249c1d Update Helix SDK to latest version (#12156)
They added retry logic inside of the SDK to deal with some expected Helix API responses.
2018-12-20 19:46:22 +01:00
dotnet bot ccd7b52ca8 Add System.Private.CoreLib shared sources (#12162)
Taken from corefx commit 5956ad35864352b38c53aa8c2d1ce012c96b168d. Subsequent updates will happen via a mirroring bot.
2018-12-20 18:51:17 +01:00
Zoltan Varga 53f091ea4f [runtime] Avoid typedref returns from icalls, wasm doesn't support them. (#12142)
* [runtime] Convert TypedReference icalls to handles, return the result using an out argument since wasm doesn't support TypedReference returns from icalls.

* Bump corlib version.

* [runtime] Change ArgIterator icalls to return typedref results using an out argument since wasm doesn't support typedref returns from icalls.

* Use MONO_HANDLE_RAW () only at the end.
2018-12-20 10:25:47 -05:00
Alexander Köplinger 5855fcd47b Bump ms-test-suite (#12150)
Brings in disabling of the ThreadLocalTests.RunThreadLocalTest8_Values_NegativeCases test (https://github.com/xamarin/ms-test-suite/pull/3)
2018-12-20 15:21:25 +01:00
Marek Safar 729bd4e45d Bootstraps netcore build (#12120)
This does not build but puts placeholders for syncing in place
2018-12-20 14:19:15 +01:00
monojenkins d6a9dc0a50 [bcl] Update BCL Linked Size (#11996) 2018-12-20 13:56:52 +01:00
Bernhard Urban d5b777ea13 [sdks] Add a XCODE32_DIR make variable and use it to compile the 32 bit cross compilers. (#12055)
Forward port of #10139

Needed for arm64_32 (#11691): We still need to build AOT compilers that are 32bit, which is only possible with Xcode9. However, arm64_32 needs Xcode10.
2018-12-20 13:40:54 +01:00
Larry Ewing 671708c403 Skip TypedReferenceTest fixture for WASM as it causes a runtime abort (#12124)
The sdks/wasm run-all-corlib target currently aborts in the TypedReferenceTest fixture. Skip it in that case by adding it to the NotWasm category.
2018-12-20 13:22:31 +01:00
Larry Ewing 3d64ae0618 Allow urls with a blob scheme to pass validation in WASM (#12121)
Relax HttpMessageRequest url scheme validation for wasm so that urls with a blob scheme make it to the host backend. Fixes #11681

note: the browser tests fail when running chrome 71 in headless mode, they work in chrome 70 and 72
2018-12-20 13:14:39 +01:00
Jo Shields 6de9c370ec Bump to latest SQLite for Mac bundle (#12118)
* Bump to latest SQLite for Mac bundle

* Explicitly disable editline support.

SQLite assumes that if editline is enabled (the default), then NCurses was compiled with TermInfo support, which is not true on Mac
2018-12-20 12:24:47 +01:00
Jay Krell 89736b3659 Reduce extern "C", in non-public headers. 2018-12-20 02:24:51 -08:00
Zoltan Varga a46e3305c4 [wasm] Run patch with -N so it doesn't fail if called more than once. 2018-12-19 11:36:12 -05:00
guthubuser e77d5bafef Update Graphics to find err
ystem.Exception: Generic Error [GDI+ status: GenericError]
  at System.Drawing.GDIPlus.CheckStatus (System.Drawing.Status status) [0x00079] in <bb99ab19679c4cf79f4136bd0faf8b5e>:0 
  at System.Drawing.Graphics.FillRectangle (System.Drawing.Brush brush, System.Int32 x, System.Int32 y, System.Int32 width, System.Int32 height) [0x00025] in <bb99ab19679c4cf79f4136bd0faf8b5e>:0 
  at System.Drawing.Graphics.FillRectangle (System.Drawing.Brush brush, System.Drawing.Rectangle rect) [0x0002c] in <bb99ab19679c4cf79f4136bd0faf8b5e>:0 
  at (wrapper remoting-invoke-with-check) System.Drawing.Graphics.FillRectangle(System.Drawing.Brush,System.Drawing.Rectangle)
  at System.Windows.Forms.Control.PaintControlBackground (System.Windows.Forms.PaintEventArgs pevent) [0x002ff] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control.OnPaintBackground (System.Windows.Forms.PaintEventArgs pevent) [0x00000] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control.WmPaint (System.Windows.Forms.Message& m) [0x0005f] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control.WndProc (System.Windows.Forms.Message& m) [0x001a4] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.ScrollBar.WndProc (System.Windows.Forms.Message& m) [0x00000] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control+ControlWindowTarget.OnMessage (System.Windows.Forms.Message& m) [0x00000] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.Control+ControlNativeWindow.WndProc (System.Windows.Forms.Message& m) [0x0000b] in <69ecb40f27a1431a99620933ba9a8b39>:0 
  at System.Windows.Forms.NativeWindow.WndProc (System.IntPtr hWnd, System.Windows.Forms.Msg msg, System.IntPtr wParam, System.IntPtr lParam) [0x00085] in <69ecb40f27a1431a99620933ba9a8b39>:0
2018-12-19 10:33:31 -05:00
Ankit Jain 56581e9cc4 [MacSDK] Bump NuGet to 4.8.1 2018-12-19 14:03:23 +01:00
Alexander Kyte 713162263d [crash] Fix reported utf encoding (#12123) 2018-12-19 07:48:16 -05:00
Zoltan Varga 0af7408340 [wasm] Enable EMULATED_FUNCTION_POINTERS. (#12077)
* [wasm] Add the fix for https://github.com/kripken/emscripten/issues/7399 as a patch for emscripten.

* [wasm] Factor out some flags from the makefile targets.

* [wasm] Enable EMULATED_FUNCTION_POINTERS.
2018-12-18 17:00:44 -05:00
Zoltan Varga a92701bd18 [aot] Add MONO_PATCH_INFO_INTERRUPTION_REQUEST_FLAG to the preinited got slots. (#12075) 2018-12-18 16:50:51 -05:00
Jay Krell 399264331b Reduce but don't eliminate excess extern "C".
G_BEGIN_DECLS is almost never needed. Esp. around entire files.
It is for "the OS" and interoperation with some code that is still C, like profilers.

MONO_BEGIN_DECLS is often used in internal headers, in which case the same, but
not addressed here.

MONO_BEGIN_DECLS is often used in public headers, along with comprehensive
MONO_API, in which case it is redundant. This would be useful if/when mono
goes back to using .def files, which are a good idea for multiple reasons.
2018-12-18 16:03:04 -05:00
Jay Krell 2f0b4b8593 Remove ves_icall_System_Threading_Thread_current_lcid.
Probably unused since a0c6e79318 in 2004.
Certainly unused since cc9c53a109 in 2008.
Except for use by MERP, replace with its implementation -- MONO_LOCALE_INVARIANT.
2018-12-18 15:58:05 -05:00
Ankit Jain e70f02a4c2 Bump msbuild to track xplat-master 2018-12-18 16:28:45 +01:00
Zoltan Varga 475431927c [jit] Call mono_register_jit_icall_full () in more places so most jit icalls can be called directly during AOT. (#12076)
* [jit] Call mono_register_jit_icall_full () in more places so most jit icalls can be called directly during AOT.

* Fix a c++-ism.

* Fix a c++-ism.

* Fix a c++-ism.
2018-12-18 08:18:28 -05:00
Martin Baulig e72f0a8a03 [gensources]: Add platform/project logic to tests.
The gensources tool now supports platform/specific .sources for nunit and xunit tests.
2018-12-18 13:14:07 +01:00
Maxim Lipnin 787c851fa5 Fix IndexOutOfRangeException in MethodInfo.ReturnParameter.IsDefined(type) 2018-12-18 12:23:59 +01:00
Jay Krell ea12da137a Null terminate in mono_string_to_byvalstr like the comment says (#11985)
and like mono_string_to_byvalwstr does and like the code
makes room for.
2018-12-17 16:41:46 -05:00
Jay Krell 05049138ec Remove MONO_HANDLE_ARRAY_SETRAW. 2018-12-17 16:40:54 -05:00
Jay Krell 2b6373afeb [Coop] Convert System.Globalization.CompareInfo. (#12063)
This is a subset of https://github.com/mono/mono/pull/12023, maybe easier to review
in smaller pieces.

Alternatives:
 1. Move more to managed.
 2. Remove the feature.
2018-12-17 16:35:19 -05:00
Jay Krell f8dbcf5ac7 [Coop] Mark RegisterReportingForNativeLib_internal NOHANDLES(). 2018-12-17 16:29:47 -05:00
Jb Evain 2993fa3281 [Mono.Debugger.Soft] Fix reading custom attribute named arguments on old protocol versions 2018-12-17 12:47:14 +01:00
Zoltan Varga f2d43e98d7 [wasm] Pass the bindings assembly to the linker. (#12061) 2018-12-17 06:20:36 -05:00
Johan Lorensson d42d675b81 Windows x64 LLVM assert support + MSVC only for none cross compiler build. (#11946)
* Add support for LLVM asserts in internal LLVM build on Windows.

* Only build LLVM using MSVC if not cross compiling.

If not cross compiling, building runtime where host/target is Windows, only
build and use LLVM as part of msvc build (only supported configuration),
disabled on gcc build.

Enforce 64-bit LLVM support when building using Visual Studio solution file.

* Disable Windows LLVM Visual Studio build on unsupported configurations.

Automatically disable Windows LLVM build in Visual Studio. This enables
the option to configure using --enable-llvm but still build all runtime
configurations from within Visual Studio. A warning will be issued into
build logs when LLVM support is disabled for a specific build configuration.

* Fix so build-init always have cygconf.h available when needed.
2018-12-14 15:45:33 -05:00
Jay Krell 1503ca4952 Cache MonoMethod in ves_icall_System_Security_SecureString_EncryptInternal / ves_icall_System_Security_SecureString_DecryptInternal. 2018-12-14 15:22:22 -05:00
Zoltan Varga d8faa8e881 [llvmonly] Emit unbox trampolines as 2 tables instead of a lookup function, this takes less space that the switch statement (#12054)
in the lookup function.
2018-12-13 23:16:48 -05:00
Zoltan Varga 0212106d36 [wasm] Add more helper make targets. (#12052) 2018-12-13 22:52:58 -05:00
Egor Bogatov 622609d54b Get rid of Registry in XmlReader (#12008) 2018-12-13 16:20:46 -05:00
Alexander Kyte 9b81922a62 [runtime] Don't probe aot cache on android 2018-12-13 16:08:12 -05:00
Alexander Kyte a8d10611ac [runtime] Fix aot mode double init check 2018-12-13 15:09:58 -05:00
Alexander Kyte 799991bc34 [runtime] Don't assert when MONO_AOT_MODE_NONE passed to setter 2018-12-13 14:31:22 -05:00
Alexander Kyte cc7aefb008 [runtime] Don't probe for assemblies when MONO_AOT_MODE_NONE is set 2018-12-13 14:30:44 -05:00
Jay Krell 3fbafe6550 Fix MonoSortKey native/managed layout mismatch. (#12043)
Fix MonoSortKey native/managed layout mismatch.

MonoSortKey native:
https://github.com/mono/mono/blob/f019810b12ba130b7fed1cd41bb2eaed04ececef/mono/metadata/object-internals.h#L700

SortKey managed:
https://github.com/mono/mono/blob/f019810b12ba130b7fed1cd41bb2eaed04ececef/mcs/class/corlib/Mono.Globalization.Unicode/SortKey.cs#L69

do not agree.

Memory is corrupted and crash if you set $MONO_DISABLE_MANAGED_COLLATION=yes documented here:
https://github.com/mono/mono/blob/f019810b12ba130b7fed1cd41bb2eaed04ececef/man/mono.1#L1161

Fix is to remove the native code and replace by trivial managed.

Found testing coop-conversion of System.Globalization. https://github.com/mono/mono/pull/12023
2018-12-13 12:55:43 -05:00
Zoltan Varga 087b198c99 [wasm] Remove the old 32 cross compiler, its not used anymore. (#12046) 2018-12-13 12:09:30 -05:00
Thays Grazia 05188e03f9 [debugger] Fix test StepOutAsync (#12032)
* The problem with this flaky issue was the timing of processing of the async tasks, as it was executed in background threads it was not possible to reach the end of execution because all the foreground threads exit earlier.
The solution creates a TaskScheduler that ensure that the thread that will execute the task will be a foreground thread and then the test always works.

Fixes #6997
2018-12-13 11:50:06 -05:00
Calvin Buckley a3ef7c874e Update corefx submodule for AIX readdir_r fix (#12031)
Exposes a race condition in CoreFX when gensources tries to enumerate Cecil sources. Run it without `--trace=all`, 86 sources found. Run it with, even if redirected to `/dev/null`, 132 sources found. Eeeeeek.
2018-12-13 11:44:26 -05:00
Zoltan Varga 01f6a0203b [wasm] Avoid dedup-ing StructureToPtr/PtrToStructure wrappers, its not neccessary, and it doesn't seem to work. (#12033) 2018-12-13 10:06:34 -05:00
Jay Krell dfc517c346 [Coop] Mark 15 icalls as NOHANDLES. (#12028) 2018-12-13 09:47:49 -05:00
Kenneth Pouncey f019810b12 Merge pull request #11943 from kjpou1/wasm-test-suite
[wasm] Add browser test suite.
2018-12-13 09:13:45 -05:00
Alexander Kyte 118684e89b [runtime] Remove duplicate merp invoke line (#12036)
[runtime] Remove duplicate merp invoke line

Looks like this broke when it got squashed down, or we overlooked it. We've got two calls where we expected one.
2018-12-13 09:05:24 -05:00
Zoltan Varga 2e05d26cfa [jit] Add beginnings of llvmonly+interp mixed mode support. (#11987)
[jit] Add beginnings of llvmonly+interp mixed mode support.
2018-12-13 08:55:57 -05:00
Jay Krell 28b1e79d19 Fix two leaks in error paths. (#12042) 2018-12-13 05:17:54 -08:00
Jay Krell 5870948f56 Remove ves_icall_System_Globalization_CompareInfo_internal_index_char. (#12026)
Unused since Feb 2018 d63e8b6f5a.
2018-12-12 15:03:26 -08:00
Jay Krell 40d462b6ee Remove unused ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid. (#12024)
Remove unused ves_icall_System_Globalization_RegionInfo_construct_internal_region_from_lcid.

See 0204abe803 from 2009.
2018-12-12 17:25:40 -05:00
Jay Krell bdf4e262a0 Cleanup mono_ldstr_metadata_sig esp. remove extra mono_string_intern_checked. 2018-12-12 16:32:36 -05:00
Jay Krell 5e45fb2760 Set error in mono_string_new_utf8_len_handle, mono_string_new_len_checked. 2018-12-12 16:22:58 -05:00
Martin Baulig 41e57c671f [resx2sr]: Giving this tool some love. (#11969) 2018-12-12 09:34:54 -05:00
Jay Krell 22a4056ecf [Coop] Add typechecking to MONO_HANDLE_SETVAL and fix mistakes it finds. (#12021)
[Coop] Add typechecking to MONO_HANDLE_SETVAL and fix mistakes it finds.
2018-12-11 20:25:39 -05:00
Jay Krell 6265eb0223 Remove ERROR_DECL_VALUE. (#12012)
Remove ERROR_DECL_VALUE.
2018-12-11 14:35:43 -05:00
Calvin Buckley 0c30564bc9 for "build" config, import corlib common sources at unix instead (#11989)
...of importing it at linux/macOS

this unbreaks the build on "unix" platforms like FreeBSD and AIX

(is this all needed files, and am I doing this right?)
2018-12-10 15:01:04 -05:00
Jay Krell a91771787c [Coop] Mark System.ArgIterator all NOHANDLES. (#12003) 2018-12-10 11:39:18 -08:00
Jay Krell a29aa4ac80 Reduce lock hold times. (#11997) 2018-12-10 06:20:51 -08:00
Jay Krell de37ae3168 Inline mono_string_handle_length by making it a macro, usually. (#11994) 2018-12-10 04:04:33 -08:00
Jay Krell 3be2618c63 Quash warning icall.c:4408:12: warning: using the result of an assignment as a condition without parentheses [-Wparentheses] (#11993)
if (klass = m_class_get_parent (klass))
            ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~
icall.c:4408:12: note: place parentheses around the assignment to silence this warning
        if (klass = m_class_get_parent (klass))
                  ^
            (                                 )
icall.c:4408:12: note: use '==' to turn this assignment into an equality comparison
        if (klass = m_class_get_parent (klass))
2018-12-10 01:04:54 -08:00
Jay Krell 52a07dd48e [Coop] Convert System.Security.SecureString. (#11995) 2018-12-09 23:46:20 -08:00
Alexander Köplinger 2f678add77 Bump corefx 2018-12-09 08:09:04 -05:00
Alexis Christoforides fd424c5dd0 [corlib] Import System.IO.TextWriter/StreamWriter from CoreFX (#11783)
* [corlib] Import System.IO.TextWriter/StreamWriter from CoreFX

* Adjust a Mono test. According to CoreFX TextWriter sources, CoreNewLine should only be used for read-only purposes.

* Bump CoreCLR for bug fix on test which becomes much flakier apparently with this patch

* Bump corefx

* Bump API snapshot submodule

* [csproj] Update project files
2018-12-09 08:05:45 -05:00
monojenkins 2cdcf190af [bcl] Update BCL Linked Size 2018-12-08 18:43:32 +01:00
Jay Krell ce1b1cd473 sizeof (gpointer) => sizeof (target_mgreg_t). (#11981) 2018-12-08 08:48:47 -08:00
Jay Krell cdf8c2923e [sgen] Make CHECK_CANARY_FOR_OBJECT a function. (#11971) 2018-12-08 02:47:37 -08:00
Jay Krell fd1458579f marshal.c cleanup (#11968)
- Reduce length computations of string builders.
 - Handle zero sized StringBuilder correctly (initialize the first
   not just the second character).
 - Check for overflow correctly in StringBuilder -- include offset.
 - Fix prototype of mono_string_to_byvalstr (gpointer vs. char*)
 - Fix prototype of mono_string_to_byvalwstr (gpionter vs. gunichar2*).
 - Single point of exit in mono_string_builder_to_utf8.
2018-12-08 02:05:19 -08:00
Kenneth Pouncey beb8397421 Address review comments 2018-12-07 15:55:23 +01:00
Larry Ewingandkjpou1 904e8d48ff Update sdks/wasm/tests/browser/http-spec.js
Update with review suggestion

Co-Authored-By: kjpou1 <[email protected]>
2018-12-07 15:38:42 +01:00
Larry Ewingandkjpou1 039044d320 Update sdks/wasm/tests/browser/http-spec.js
Update with review comment suggestion

Co-Authored-By: kjpou1 <[email protected]>
2018-12-07 15:38:16 +01:00
Alexis Christoforides 449e36638f [corlib] Import FileSystemInfo and family from CoreFX (#11342)
Includes the following from System.IO:

* FileSystemInfo
* FileInfo
* DirectoryInfo
* Directory
* FileSystem
* Path `Join()` Span API

and all of System.IO.Enumeration namespace.

Adds about 1600 System.IO tests

Behavior changes:
* `File.Replace` now replaces files even if they are read-only (using the `rename` syscall on Unix)
* Directory enumeration is no longer stable in the way that many Mono tests expect
* Some changes in when/whether some representations of directories contain a trailing separator character
* Changes in which exceptions are thrown (sometimes these are platform-dependent on CoreFX)

Issues:
* https://github.com/dotnet/corefx/issues/33486
* https://github.com/dotnet/corefx/issues/33490

Part of #7246
2018-12-07 15:02:23 +01:00
Jay Krell 3643f411a0 Fix cross compile of libtest. (#11865)
CC       libtest_la-libtest.lo
    <inline asm>:37:2: error: instruction requires: Not 64-bit mode
            popl %eax
            ^
    ... same error many times

Fix ThisCall tests.

Libtest.c needs to be C++ for Visual C+++ to accept __thiscall.
gcc accepts __thiscall in C.

Visual C++ only accepts __thiscall on member functions and function pointers,
not globals. Gcc accepts on globals also.
So test what we can.

add extern C

Limit thiscall testing to Win32, even if gcc has more support.
2018-12-06 10:49:33 -08:00
Jay Krell c80110cb05 [w32file-unix] Use mono_dl_open in place of dlopen
* Cleanup boehm/dlopen per https://github.com/mono/mono/pull/11853#discussion_r238861650.
https://github.com/mono/mono/issues/11936

* s/mono_dlopen/mono_dl_open s/dlsym/mono_dl_symbol

* s/dlclose/mono_dl_close

* Fix mono_dl_symbol use.

* Fix mono_dl_open call.

* Fix type of libc_handle for mono_dl vs. regular dl.
2018-12-06 13:48:20 -05:00
Jay Krell 943fa94bce Fix CHECK_CANARY_FOR_OBJECT. (#11957)
Fix CHECK_CANARY_FOR_OBJECT.

..\mono\metadata\sgen-mono.c(1443): warning C4390: ';': empty controlled statement found; is this the intent?

(Why is this not a function?)
2018-12-06 12:55:37 -05:00
Jay Krell eeb7e6bdb5 Remove mono_array_to_byvalarray and mono_byvalarray_to_array. (#11954)
Remove mono_array_to_byvalarray      and mono_byvalarray_to_array.

Only   mono_array_to_byte_byvalarray and mono_byvalarray_to_byte_array are used.
2018-12-06 11:55:51 -05:00
Alexander Köplinger ee3afd3103 [acceptance-tests] Add a generated file to .gitignore 2018-12-06 17:19:48 +01:00
Alexander Kyte e1461ebc85 [crash] Switch crash reporting writers to no-allocate + validate json (#11884)
* [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

* [crash] Disable merp-json-valid test on non-OSX
2018-12-06 10:57:05 -05:00
Jay Krell ff04de942b [cxx] Fix arm+arm64 since 9a9439329b. (#11958) 2018-12-06 15:56:32 +01:00
Jay Krell 13e9729ed6 Eliminate mgreg_t in favor of target_mgreg_t and host_mgreg_t. And one minor fix. (#11952)
* Elimination of mgreg_t in favor of target_mgreg_t and host_mgreg_t.

* [mips] Fix one host vs. target size.

* easier to read in narrow screen

* For posterity.
2018-12-06 08:23:39 -05:00
Alexander Köplinger e031ff4425 [ci] Replace plus with uri-encoded version in build url reported to Helix 2018-12-06 14:00:21 +01:00
Jo Shields 21dcc74a7a [Win32] Enable BTLS in Windows builds (#11947) 2018-12-06 12:59:09 +01:00
Jay Krell 8525f4c679 Fix race condition in mono_string_builder_new. (#11955)
Fix race condition in mono_string_builder_new.
2018-12-06 06:25:45 -05:00
Calvin Buckley bbb475d058 Fix regression with building PPC JIT (#11948)
* Fix regression with building PPC JIT

d5547b1929 made an incorrect change
to `mini-ppc.c` that wouldn't build; revert that file.

* Switch to fixing mini-ops.h instead
2018-12-06 10:41:39 +01:00
Egor Bogatov cd21cdb1b6 Display AM/PM for ko-KR culture (#11327)
Fixes https://github.com/mono/mono/issues/11317
(I guess I need to update culture-info-tables.h via make but it doesn't work on Windows, I have to switch to macOS).
2018-12-06 10:13:31 +01:00
Jay Krell 858434201d Fix cross compile of libtest.
CC       libtest_la-libtest.lo
    <inline asm>:37:2: error: instruction requires: Not 64-bit mode
            popl %eax
            ^
    ... same error many times

Fix ThisCall tests.

Libtest.c needs to be C++ for Visual C+++ to accept __thiscall.
gcc accepts __thiscall in C.

Visual C++ only accepts __thiscall on member functions and function pointers,
not globals. Gcc accepts on globals also.
So test what we can.

add extern C

Limit thiscall testing to Win32, even if gcc has more support.
2018-12-06 00:46:21 -08:00
Jay Krell 7f729566b4 Adjust test (not runtime) to workaround Windows i386 GCC ABI bug. 2018-12-06 00:11:13 -08:00
Jay Krell 71d46c815d Remove excess extern "C" per https://github.com/mono/mono/pull/11121#issuecomment-444562586. (#11950)
Remove one excess extern "C" per https://github.com/mono/mono/pull/11121#issuecomment-444562586.

There are many more.
2018-12-06 01:25:39 -05:00
Kenneth Pouncey bb6aae9a6e Small clean up to use path variable instead of relative path. 2018-12-06 05:15:12 +01:00
Jay Krell 9a9439329b Host/target corrections and clarifications and cleanup. (#11887) 2018-12-05 18:01:55 -08:00
Alexander Kyte c84ae2e7e9 [crash] Add crash reporter logger (#11855)
* [crash] Add crash reporter logger

* [crash] Disable mono-merp when disabling crash reporting
2018-12-05 17:19:34 -05:00
Jay Krell 4a5d19498b Move MONO_STRFTIME_T and MONO_STRFTIME_F to mono-time.h. 2018-12-05 16:50:29 -05:00
Jay Krell 66d1da652e strftime(%F) and strftime(%T) are non-portable shorthands that produce
a lot of warnings in the build. Expand them to their portable equivalents.
2018-12-05 16:50:29 -05:00
Zoltan Varga d5547b1929 [jit] Rename the textual names of several instructions so they match the opcode names. (#11938) 2018-12-05 16:05:39 -05:00
Jay Krell 460c8b4c16 Split mono_class_init into mono_class_init and mono_class_init_internal, add GC mode transition to first. (#11121)
mono_class_init_internal is what mono_class_init was.
mono_class_init *adds* missing GC mode transitions and calls mono_class_init_internal.

Replace mono_class_init with mono_class_init_internal.
2018-12-05 12:27:44 -08:00
Jay Krell 45407470db Quash some "may be used uninitialized" warnings.
/s/mono/mono/mini/interp/interp.c: In function 'interp_entry_from_trampoline':
/s/mono/mono/mini/interp/interp.c:2422:3: warning: 'orig_domain' may be used uninitialized in this function [-Wmaybe-uninitialized]
   mono_threads_detach_coop (orig_domain, &attach_cookie);
   ^
/s/mono/mono/mini/interp/interp.c: In function 'interp_exec_method_full':
/s/mono/mono/mini/interp/interp.c:2695:4: warning: 'locals' may be used uninitialized in this function [-Wmaybe-uninitialized]
    memset (locals, 0, rtm->locals_size);
    ^
/s/mono/mono/mini/method-to-ir.c: In function 'mini_handle_enum_has_flag':
/s/mono/mono/mini/method-to-ir.c:3416:9: warning: 'load' may be used uninitialized in this function [-Wmaybe-uninitialized]
    load = mono_decompose_opcode (cfg, load);
         ^
At least the first two seem to be compiler weakness.
2018-12-05 13:14:00 -05:00
Jay Krell 40f86511d4 Fix a bunch of warnings. (#11859)
* Fix a bunch of warnings.

/s/mono/mono/metadata/marshal.c:4862:72: warning: format specifies type 'unsigned long' but the argument has type 'gsize' (aka 'unsigned int') [-Wformat]
                mono_error_set_out_of_memory (error, "Could not allocate %lu bytes", size);
                                                                         ~~~         ^~~~
                                                                         %zu
/s/mono/mono/metadata/marshal.c:6229:1: warning: unused function 'install_noilgen' [-Wunused-function]
install_noilgen (void)
^
                                                        %llx

/s/mono/mono/metadata/w32file-unix.c:4877:147: warning: format specifies type 'void *' but the argument has type 'gint' (aka 'int') [-Wformat]
        mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_LAYER_FILE, "%s: Unlocking fd %p, offset %" G_GINT64_FORMAT ", length %" G_GINT64_FORMAT, __func__, ((MonoFDHandle*) filehandle)->fd, (gint64) offset, (gint64) length);
                                                                                   ~~                                                                    ^~

/s/mono/mono/metadata/w32process-unix-internals.h:44:1: warning: unused function 'mono_w32process_module_free' [-Wunused-function]
mono_w32process_module_free (MonoW32ProcessModule *module)
^

/s/mono/mono/utils/mono-threads-android.c:44:1: warning: no previous prototype for function 'mono_threads_platform_get_stack_bounds' [-Wmissing-prototypes]
mono_threads_platform_get_stack_bounds (guint8 **staddr, size_t *stsize)
^

/s/mono/mono/mini/interp/transform.c:1666:15: warning: unused variable 'vt' [-Wunused-variable]
                MonoVTable *vt = mono_class_vtable_checked (domain, target_method->klass, error);
                            ^
/s/mono/mono/utils/mono-counters.c:547:55: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'gssize' (aka 'int') [-Wformat]
                fprintf (outfile, ENTRY_FMT "%zd\n", counter->name, *(gssize*)buffer);
                                             ~~~                    ^~~~~~~~~~~~~~~~
                                             %td

/s/mono/mono/sgen/sgen-debug.c:1066:72: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'int' [-Wformat]
        fprintf (heap_dump_file, "<occupied offset=\"%zd\" size=\"%zd\"/>\n", start - section_start, end - start);
                                                     ~~~                      ^~~~~~~~~~~~~~~~~~~~~
                                                     %d
/s/mono/mono/sgen/sgen-debug.c:1066:95: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'int' [-Wformat]
        fprintf (heap_dump_file, "<occupied offset=\"%zd\" size=\"%zd\"/>\n", start - section_start, end - start);
                                                                  ~~~                                ^~~~~~~~~~~
                                                                  %d
/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned int') [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/sgen/sgen-memory-governor.c:309:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->promoted_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~

/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned long long') [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/metadata/w32file-unix.c:70:9: warning: 'INVALID_HANDLE_VALUE' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/metadata/w32handle.h:19:9: note: previous definition is here
        ^
/s/mono/mono/metadata/handle.c:159:31: warning: 'extern' variable has an initializer [-Wextern-initializer]
extern MonoThreadInfo * const mono_thread_info_current_var = NULL;
                              ^
/s/mono/mono/mini/branch-opts.c:117:18: warning: unused variable 'int_cmov_opcodes' [-Wunused-const-variable]
static const int int_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/branch-opts.c:130:18: warning: unused variable 'long_cmov_opcodes' [-Wunused-const-variable]
static const int long_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/interp/interp.c:1233:1: warning: unused label 'exit_pinvoke' [-Wunused-label]
exit_pinvoke:
^~~~~~~~~~~~~
/s/mono/mono/mini/interp/interp.c:1900:1: warning: unused label 'exit_icall' [-Wunused-label]
exit_icall:
^~~~~~~~~~~

/s/mono/mono/mini/interp/transform.c:1668:7: warning: unused variable 'called_inited' [-Wunused-variable]
                int called_inited = vt->initialized;
                    ^
                                 ^/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned long long')
      [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/sgen/sgen-descriptor.c:132:52: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Ptrfree descriptor %p, size: %zd", (void*)desc, stored_size);
                                                                 ^
/s/mono/mono/sgen/sgen-descriptor.c:145:70: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Largebitmap descriptor %p, size: %zd, last set: %d", (void*)desc, stored_size, last_set);
                                                                                   ^
/s/mono/mono/sgen/sgen-descriptor.c:156:80: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                        SGEN_LOG (6, "Runlen descriptor %p, size: %zd, first set: %d, num set: %d", (void*)desc, stored_size, first_set, num_set);
                                                                                                    ^
/s/mono/mono/sgen/sgen-gc.c:1252:82: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int') [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
                                                                                               ^
/s/mono/mono/sgen/sgen-nursery-allocator.c:800:114: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (p)), sgen_safe_object_get_size (p));
                                                      ~~~                                                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~
/s/mono/mono/sgen/sgen-pinning.c:213:117: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (ptr)), sgen_safe_object_get_size (ptr));
                                                      ~~~                                                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~
/s/mono/mono/metadata/w32file-unix.c:70:9: warning: 'INVALID_HANDLE_VALUE' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/metadata/w32handle.h:19:9: note: previous definition is here
        ^
/s/mono/mono/metadata/handle.c:159:31: warning: 'extern' variable has an initializer [-Wextern-initializer]
extern MonoThreadInfo * const mono_thread_info_current_var = NULL;
                              ^
/s/mono/mono/metadata/sgen-mono.c:107:95: warning: cast to 'gpointer' (aka 'void *') from smaller integer type 'MonoGCDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
        SGEN_LOG (8, "Adding value remset at %p, count %d, descr %p for class %s (%p)", dest, count, (gpointer)m_class_get_gc_descr (klass), m_clas...
                                                                                                     ^
/s/mono/mono/metadata/sgen-mono.c:1741:83: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Profiler root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
                                                                                                ^
/s/mono/mono/mini/helpers.c:72:9: warning: 'ARCH_PREFIX' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/mini/helpers.c:68:9: note: previous definition is here
        ^
/s/mono/mono/mini/branch-opts.c:117:18: warning: unused variable 'int_cmov_opcodes' [-Wunused-const-variable]
static const int int_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/branch-opts.c:130:18: warning: unused variable 'long_cmov_opcodes' [-Wunused-const-variable]
static const int long_cmov_opcodes [] = {
                 ^
/s/mono/mono/mini/mini-arm.c:7363:1: warning: no previous prototype for function 'mono_arch_get_seq_point_info' [-Wmissing-prototypes]
mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code)
^
/s/mono/mono/mini/exceptions-arm.c:241:65: warning: implicit conversion from 'unsigned long' to 'int' changes value from 18446744073709551612 to -4
      [-Wconstant-conversion]
        mono_add_unwind_op_offset (unwind_ops, code, start, ARMREG_LR, - sizeof (mgreg_t));
        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~
/s/mono/mono/mini/mini-unwind.h:132:170: note: expanded from macro 'mono_add_unwind_op_offset'
  ...do { (op_list) = g_slist_append ((op_list), mono_create_unwind_op ((code) - (buf), DW_CFA_offset, (reg), (offset))); } while (0)
                                                 ~~~~~~~~~~~~~~~~~~~~~                                         ^~~~~~
/s/mono/mono/mini/interp/interp.c:1233:1: warning: unused label 'exit_pinvoke' [-Wunused-label]
exit_pinvoke:
^~~~~~~~~~~~~
/s/mono/mono/mini/interp/interp.c:1900:1: warning: unused label 'exit_icall' [-Wunused-label]
exit_icall:
^~~~~~~~~~~
/s/mono/mono/mini/interp/transform.c:1668:7: warning: unused variable 'called_inited' [-Wunused-variable]
                int called_inited = vt->initialized;
                    ^

/s/mono/mono/utils/mono-time.c:23:34: warning: unused variable 's_TimebaseInfo' [-Wunused-variable]
static mach_timebase_info_data_t s_TimebaseInfo;
                                 ^
/s/mono/mono/sgen/sgen-debug.c:1139:4: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword' (aka 'unsigned long long')
      [-Wformat]
                        safe_object_get_size (obj));
                        ^~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-debug.c:37:30: note: expanded from macro 'safe_object_get_size'
                                ^
/s/mono/mono/sgen/sgen-descriptor.c:132:52: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Ptrfree descriptor %p, size: %zd", (void*)desc, stored_size);
                                                                 ^
/s/mono/mono/sgen/sgen-descriptor.c:145:70: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Largebitmap descriptor %p, size: %zd, last set: %d", (void*)desc, stored_size, last_set);
                                                                                   ^
/s/mono/mono/sgen/sgen-descriptor.c:156:80: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                        SGEN_LOG (6, "Runlen descriptor %p, size: %zd, first set: %d, num set: %d", (void*)desc, stored_size, first_set, num_set);
                                                                                                    ^
/s/mono/mono/sgen/sgen-gc.c:1252:82: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int') [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
                                                                                               ^
/s/mono/mono/sgen/sgen-nursery-allocator.c:800:114: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (p)), sgen_safe_object_get_size (p));
                                                      ~~~                                                          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~

/s/mono/mono/sgen/sgen-pinning.c:213:117: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'mword'
      (aka 'unsigned long long') [-Wformat]
  ...SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (ptr)), sgen_safe_object_get_size (ptr));
                                                      ~~~                                                              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                                      %llu
/s/mono/mono/sgen/sgen-gc.h:143:69: note: expanded from macro 'SGEN_LOG'
                mono_gc_printf (sgen_gc_debug_file, "%s " format "\n", logTime, ##__VA_ARGS__); \
                                                                                  ^~~~~~~~~~~
/s/mono/mono/utils/mono-logger-internals.h:109:34: note: expanded from macro 'mono_gc_printf'
        fprintf (gc_log_file, format, ##__VA_ARGS__);   \
                                        ^~~~~~~~~~~

/s/mono/mono/metadata/w32file-unix.c:70:9: warning: 'INVALID_HANDLE_VALUE' macro redefined [-Wmacro-redefined]
        ^
/s/mono/mono/metadata/w32handle.h:19:9: note: previous definition is here
        ^

/s/mono/mono/metadata/handle.c:159:31: warning: 'extern' variable has an initializer [-Wextern-initializer]
extern MonoThreadInfo * const mono_thread_info_current_var = NULL;
                              ^
/s/mono/mono/metadata/sgen-mono.c:107:95: warning: cast to 'gpointer' (aka 'void *') from smaller integer type 'MonoGCDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
        SGEN_LOG (8, "Adding value remset at %p, count %d, descr %p for class %s (%p)", dest, count, (gpointer)m_class_get_gc_descr (klass), m_clas...
                                                                                                     ^
/s/mono/mono/metadata/sgen-mono.c:1741:83: warning: cast to 'void *' from smaller integer type 'SgenDescriptor' (aka 'unsigned int')
      [-Wint-to-void-pointer-cast]
                SGEN_LOG (6, "Profiler root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);

* PR: Remove comments.

* Preserve unsignedness of GC descriptor in logging.
2018-12-05 08:22:59 -08:00
Calvin Buckley 4af055c794 Fix PowerPC regression caused by tracing changes (#11907)
2b029b3df4 broke ppc JIT tracing by
moving it into mini and changing the arguments. Since the mini IR
emitter handles tracing now, rip out the tracing code from the JIT.

(Looks like SPARC will need a similar change, but someone needs to
love SPARC first.)
2018-12-05 15:48:35 +01:00
Kenneth Pouncey 6f5204f5f1 Remove errant binary. 2018-12-05 14:12:47 +01:00
Kenneth Pouncey 23e5688caf [wasm] Add browser test suite.
The existing tests work with JavaScript Engines and do not have any way to test code that works only in the browser.   The JavaScript Engines do not have access to any browser API’s so functionality like the WasmHttpMessageHandler can not be tested.

- Add test suite that uses Headless Chrome and Node.js with Karma.
- Allows testing the browser API.
2018-12-05 13:52:00 +01:00
Jay Krell d62f73a79d Fix warnings and race condition in time keeping. (#11862)
* Fix warnings and race condition in time keeping.

/s/mono/mono/utils/mono-time.c:23:34: warning: unused variable 's_TimebaseInfo' [-Wunused-variable]
static mach_timebase_info_data_t s_TimebaseInfo;

/s/mono/mono/utils/mono-time.c:112:1: warning: unused function 'get_boot_time' [-Wunused-function]

* Remove boot_time, unused since https://github.com/mono/mono/commit/06a4273d73cfa732d911bdaf50f752c025a0665c.
2018-12-04 22:43:41 -08:00
Jay Krell bd96170808 Fix always-true assertion. (#11863)
Alternatively, safer, since it never worked, remove it.

   /s/mono/mono/utils/mono-error.c:124:28: warning: comparison of constant 'MONO_ERROR_CLEANUP_CALLED_SENTINEL' (65535) with expression of type 'short' is always true [-Wtautological-constant-out-of-range-compare]
            g_assert (orig_error_code != MONO_ERROR_CLEANUP_CALLED_SENTINEL);
                      ~~~~~~~~~~~~~~~ ^  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Fixing this reveals problems in ves_icall_System_Threading_Thread_GetAbortExceptionState,
i.e. the repaired assert fails, so this depends on https://github.com/mono/mono/pull/11889.

Also cleanup and optimize nearby.
2018-12-04 18:24:22 -08:00
Jay Krell ad6de27b90 Fix more warnings. (#11853)
This isn't correct for Win64 but that should be ok.
It is correct for all other platforms.

/s/mono/mono/sgen/sgen-memory-governor.c:309:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->promoted_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:310:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:311:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size_in_use / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:312:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:313:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:321:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:322:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:332:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:333:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->los_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:337:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size / 1024,
                                ^~~~~~~~~~~~~~~~~~~~~~~~
/s/mono/mono/sgen/sgen-memory-governor.c:338:5: warning: format specifies type 'ssize_t' (aka 'long') but the argument has type 'unsigned int' [-Wformat]
                                entry->major_size_in_use / 1024);
                                ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/s/mono/mono/metadata/w32file-unix.c:4688:1: warning: no previous prototype for function 'ves_icall_System_IO_DriveInfo_GetDriveType' [-Wmissing-prototypes]
ves_icall_System_IO_DriveInfo_GetDriveType (const gunichar2 *root_path_name, gint32 root_path_name_length, MonoError *error)
^

/s/mono/mono/metadata/remoting.c:2143:1: warning: no previous prototype for function 'mono_context_set_icall' [-Wmissing-prototypes]
mono_context_set_icall (MonoAppContext *new_context_raw)
^

/s/mono/mono/mini/mini-posix.c:229:2: warning: unused variable 'ctx' [-Wunused-variable]
        MONO_SIG_HANDLER_GET_CONTEXT;

And beware icall-decl.h + Boehm producing:
w32file-unix.c:4905:16: error: implicit declaration of function 'GC_dlopen' is invalid in C99 [-Werror,-Wimplicit-function-declaration]
        libc_handle = dlopen ("/usr/lib/libc.dylib", 0);
                      ^
or, if you fix that, unreferenced symbol _GC_dlopen.
2018-12-04 16:18:02 -08:00
Jay Krell dd58c519e4 Fix warnings and a C++ error.
mono/master 32beba680e with no local edits

The C++ compilation was likely an accident and I'll try again after git clean.

jaymac1:mono jay$ cat sdks/Mak*g
ENABLE_CXX=1

will run again with git clean.

 make -C sdks/builds build-ios-cross32 build-android-cross-arm build-android-cross-x86

/s/mono/mono/mini/mini-llvm.c:7729:18: warning: unused variable 'iter' [-Wunused-variable]
                GHashTableIter iter;
                               ^
/s/mono/mono/mini/mini-llvm.c:7730:15: warning: unused variable 'method' [-Wunused-variable]
                MonoMethod *method;
                            ^
/s/mono/mono/mini/mini-llvm.c:7731:11: warning: unused variable 'callers' [-Wunused-variable]
                GSList *callers, *l, *l2;
                        ^
/s/mono/mono/mini/mini-llvm.c:7731:21: warning: unused variable 'l' [-Wunused-variable]
                GSList *callers, *l, *l2;
                                  ^
/s/mono/mono/mini/mini-llvm.c:7731:25: warning: unused variable 'l2' [-Wunused-variable]
                GSList *callers, *l, *l2;
                                      ^
/s/mono/mono/mini/mini-llvm.c:9022:13: error: cannot initialize a variable of type 'CallSite *' with an lvalue of type 'gpointer' (aka 'void *')
                CallSite *site = g_ptr_array_index (module->callsite_list, sindex);
                          ^      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

/s/mono/mono/mini/mini-llvm.c:9002:17: warning: unused variable 'iter' [-Wunused-variable]
        GHashTableIter iter;
                       ^
/s/mono/mono/mini/mini-llvm.c:9004:10: warning: unused variable 'callers' [-Wunused-variable]
        GSList *callers, *l;
                ^
/s/mono/mono/mini/mini-llvm.c:9004:20: warning: unused variable 'l' [-Wunused-variable]
        GSList *callers, *l;
2018-12-04 17:09:10 -05:00
Alexander Köplinger feb342ae4f Add PathHelpers.cs to EXTRA_DIST to fix tarball build 2018-12-04 22:28:18 +01:00
Alexander Kyte 436a44a764 Merge pull request #11636 from alexanderkyte/crash_reporter_no_timeout
[crash] Force lldb/gdb traces to appear during hangs
2018-12-04 14:12:24 -05:00
Alexander Kyte 9994a181fd [crash] Early exit if callbacks not set (#11909) 2018-12-04 13:40:00 -05:00
Jay Krell eca15996c7 Remove extra percent from GSIZE_FORMAT.
Every user puts one on and the result does not work.
2018-12-04 11:03:20 -05:00
Marek Safar fa06ac818c [corlib] Make by-ref struct actually ref now C# supports them. (#11871)
* [corlib] Make by-ref struct actually ref now C# supports them.

This is technically breaking change but the types are already specialized
in C# compiler to be ref structs therefore the breaking change is more
theoretical than practical

* [mcs] Improves error reporting for special runtime types

* Bump API snapshot submodule
2018-12-04 16:53:08 +01:00
Rolf Bjarne Kvinge 632bb59b21 [System] Implement a helper function to create unique temporary directories and use it in tests. (#11831)
While working on PR #11829 I stress-tested the tests by running multiple test
runs in parallel, and it turned out that many tests were not parallel-safe,
because they used the same temporary file names and ended up stomping on
eachother.

So I implemented a helper method that creates a guaranteed unique temporary
directory, and I've changed all tests to use this new helper method.
2018-12-04 16:43:23 +01:00
Neale Ferguson 18fdc10cc1 Fix order of parameter processing. Note the offsets appear different to the size of the variables being passed but s390x will align parameters on 64-bit boundaries which is why the gbooleans appear to be treated as gulongs. (#11912)
Fix order of parameter processing. 

New parameter addition was put in wrong spot in the parameter list. Also the offsets on the stack were incorrect as 32-bit values are placed in 64-bit aligned slots on s390x. Therefore, even though these are gbooleans the appear to be treated as gulongs.



<!--
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-12-04 10:15:57 -05:00
Bernhard Urban 2f17f4f2a2 [bcl] add fullaotinterp_llvm preset (#11847)
* [bcl] add fullaotinterp_llvm preset

That is, the AOT compiler uses the LLVM backend for BCL. AOT+LLVM is
used in the 'Release' configuration on Xamarin.iOS.

* [aot_full_interp_llvm] enable corlib tests
2018-12-04 09:56:36 -05:00
Kenneth Pouncey 8c32d109a0 [ci] Re-Enable V8 tests on wasm (#11929)
-  Found latest V8 version: v7.3.16.  Works

Resolves: https://github.com/mono/mono/issues/11908
2018-12-04 15:54:56 +01:00
Jay Krell ac688eaa5d Fix and cleanup ves_icall_System_Threading_Thread_GetAbortExceptionState.
In particular, to not fail asserts related to MONO_ERROR_CLEANUP_CALLED_SENTINEL,
which are currently missing or incorrect.
2018-12-04 09:54:42 -05:00
monojenkins cf7b6cfd5f [csproj] Update project files 2018-12-04 11:13:19 +01:00
Jb Evain 83d63bf181 [Mono.Debugger.Soft] Make exposing Cecil metadata an option 2018-12-04 11:13:19 +01:00
Jay Krell 88a1ffcf0d More mgreg_t to host_mgreg_t or target_mgreg_t conversion. (#11914)
* More mgreg_t to host_mgreg_t or target_mgreg_t conversion.
 Mostly target_mgreg_t.
Note that this is all optional, in the sense that cross compilers
never run their runtime. So mgreg_t is always target_mgreg_t, or
they are the same.
But agreement is to ban mgreg_t.
2018-12-03 23:40:05 -08:00
Zoltan Varga f24d652d56 [wasm] AOT work. (#11826)
* [bcl] Disable some tests under WASM.

* [bcl] Pass a stack mark through TypeSpec.Resolve ().

* [runtime] Avoid freeing an error which gets passed back from an icall.

* [wasm] Make Environment.GetCommandLineArgs () work. Allow excluding tests on the command line.

* Fix some stackframe tests.

* [wasm] Add a missing dependency to the ninja files.
2018-12-03 20:41:28 -05:00
Mikhail Pilin 2be08fc551 Fix race condition in XmlCharType.Instance (#11814) 2018-12-03 19:18:46 -05:00
Jay Krell 03f5674a36 Fix compilation errors targeting 32bit from 64bit host. (#11861) 2018-12-03 15:47:50 -08:00
Alexander Kyte 8ea3be0255 [runtime] Add waitpid to probed-for libc functions 2018-12-03 17:13:16 -05:00
Alexander Kyte 82e6bda20a [crash] Create supervisor thread for crash dumper 2018-12-03 17:13:16 -05:00
Alexander Kyte f2d5baf6cb [runtime] Make sure lldb/gdb dump happens when MERP fails 2018-12-03 17:13:16 -05:00
Jo Shields f885880f31 Bump version to 5.23 (#11911) 2018-12-03 22:26:36 +01:00
Shaan Nobee 9b4736d4c2 [mkbundle] Delete target directory if it exists before downloading runtime (#11876)
Fixes #11858
2018-12-03 18:30:12 +01:00
Alexander Köplinger fb2fea63fd [ci] Disable V8 tests on wasm
See https://github.com/mono/mono/issues/11908
2018-12-03 18:21:02 +01:00
Vlad Brezae e1720d0a01 [exceptions] Verbose logging for cfa_reg assertion (#11888)
[exceptions] Verbose logging for cfa_reg assertion

Historically very common and hard to reproduce assertion, which, in some cases, could be fixed just from this logging. Log example :

```
Unset cfa_reg in method <0x40011220 - (null) trampoline>. Memory around ip (0x40011220):
0x40011210  41 89 07 4c 8b 3c 24 48 83 c4 08 c3 00 00 00 00  A..L.<$H........
0x40011220  48 83 c7 10 b8 00 12 01 40 ff e0 00 00 00 00 00  H.......@.......
0x40011230  00 00 00 00 e8 c7 ef fe ff 08 f8 34 e0 55 55 55  ...........4.UUU
0x40011240  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
* Assertion: should not be reached at unwind.c:664
```
2018-12-03 11:55:53 -05:00
Alexander Köplinger 191421603b [ci] Support more OS combinations on Helix 2018-12-03 16:26:26 +01:00
Calvin Buckley f840e00f12 Fix lack of symbols in System.Native support lib on AIX (#11905)
I forgot to fix Makefile.am to check for AIX and include the unix
sources if so. Actually fixes #11895.
2018-12-03 14:40:09 +01:00
Jay Krell 3ecdd17b01 Use target offset in mono_get_delegate_virtual_invoke_impl. (#11886) 2018-12-03 14:39:19 +01:00
Jay Krell 1fa43b7cd2 Layout should not be host-sensitive, only target-sensitive. (#11885)
* Layout should not be host-sensitive, only target-sensitive.

* Always set target_sizeof_void_p.
2018-12-03 14:36:36 +01:00
Jay Krell 16baa4d205 Fix = vs. ==. (#11897) 2018-12-03 14:34:36 +01:00
Alexander Köplinger 30fbfa8c37 Add System.Buffers facade to framework assemblies list
Looks like it was forgotten.
2018-12-03 14:30:56 +01:00
Calvin Buckley 3f3c217519 Build System.Native for AIX/i (#11896)
This will probably be needed in the future; and attempts to solve
the issue with System.Random not working when running under Jenkins.
2018-12-03 12:28:45 +01:00
Jay Krell bfb314165a Fix https://github.com/mono/mono/issues/11898 (#11899)
Fix https://github.com/mono/mono/issues/11898
This regressed six months ago at https://github.com/mono/mono/pull/9503/files#r238093574.

There are two identical sounding functions:

mono_string_handle_to_utf8:
  What we usually use. Sounds reasonable. Usually is reasonable.
  Allocates with malloc.

mono_string_to_utf8str_handle:
  What should be used here. Allocates with CoTaskMemAlloc.
  So it can be freed with marshal_free => CoTaskMemFree.

i.e. The allocator and the freeer need to agree.
2018-12-03 12:20:22 +01:00
Johan Lorensson 876f22d159 Merge pull request #11873 from lateralusX/lateralusX/windows-increase-llvm-compile-rate
Increase number of compiled LLVM methods on Windows x64.
2018-12-03 09:04:13 +01:00
monojenkins c99d2de68e [csproj] Update project files 2018-12-02 09:19:53 +01:00
Martin Baulig b8f8423139 Bring the internal 'NTAuthentication' class. 2018-12-02 09:19:53 +01:00
Alexander Köplinger 793f24a07a [configure.ac] Only use AM_EXTRA_RECURSIVE_TARGETS when available (#11877)
It's only available in automake 1.13+. Since we only use it for tests
we can just make it optional on systems with earlier automake.

Fixes https://github.com/mono/mono/issues/11809
2018-12-02 03:18:58 +01:00
monojenkins 0679e4b052 [bcl] Update BCL Linked Size 2018-12-01 10:50:03 +01:00
Jay Krell 1c4d949128 Cross AOT: sizeof(gpointer) vs. sizeof(target_mgreg_t), sizeof(MonoTypedRef) vs. MONO_ABI_SIZEOF. (#11868) 2018-11-30 16:56:35 -08:00
Alexander Kyte cde8093a65 Merge pull request #11864 from jaykrell/do-not-truncate-merp-data
Do not truncate 64bit MERP hashes to 32bits.
2018-11-30 17:40:07 -05:00
Jay Krell b04d891826 Remove gratuitious ifdef and fix warning. (#11839) 2018-11-30 14:38:18 -08:00
Jay Krell d23a54bc87 [arm] [jit] s/mgreg_t/target_mgreg_t/ for clarity. (#11869) 2018-11-30 13:57:30 -08:00
Martin Baulig e14a67696f [corlib]: Bring Random from CoreFX and add RandomNumberGenerator.Fill(Span<byte>). (#11797)
This adds some `Span<byte>` overloads to `Random` and `RandomNumberGenerator`.

Part of #7737
2018-11-30 21:46:44 +01:00
Maxim Lipnin 0a86e39c9b [reflection] Import MethodBase from CoreFX (#11837)
Part of #9660.
2018-11-30 17:58:42 +01:00
lateralusX 3e77f33e0a Increase number of compiled LLVM methods on Windows x64.
* Add support for additional calling conventions supported on Windows x64.
* Add support for more call info storage types used on Windows x64.
2018-11-30 16:06:18 +01:00
Henric Müller ba89f8df45 Hide detection fixes for events
Removing BindingFlags checks from native code to instead
trust the checks made in managed code. This fixes the case
when events were incorrectly returned from types that
have overridden private or static events.
2018-11-30 15:08:32 +01:00
Jay Krell 4e34b6a8fd Do not truncate 64bit MERP hashes to 32bits.
This might invalidate all existing data however and perhaps 32bits is enough.

/s/mono/mono/utils/mono-merp.c:227:63: warning: format specifies type 'unsigned int' but the argument has type 'size_t' (aka 'unsigned long') [-Wformat]
    g_string_append_printf (output, "BlameModuleOffset: 0x%x\n", merp->moduleOffset);
							  ~~     ^~~~~~~~~~~~~~~~~~
							  %zx
/s/mono/mono/utils/mono-merp.c:231:59: warning: format specifies type 'unsigned int' but the argument has type 'guint64' (aka 'unsigned long long')
  [-Wformat]
    g_string_append_printf (output, "StackChecksum: 0x%x\n", merp->hashes.offset_free_hash);
						      ~~     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
						      %llx
/s/mono/mono/utils/mono-merp.c:232:55: warning: format specifies type 'unsigned int' but the argument has type 'guint64' (aka 'unsigned long long')
  [-Wformat]
    g_string_append_printf (output, "StackHash: 0x%x\n", merp->hashes.offset_rich_hash);
						  ~~     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
						  %llx

The first one isn't really a truncation but fix the warning.
Or use guint32 for module offsets instead of size_t.
2018-11-30 01:48:58 -08:00
Vlad Brezae 9c6d733449 [interp] Fix rethrow (#11844)
* [interp] Remove some useless code

* [interp] Remove useless variable

When unwinding, we get the last interp frame that was executing from the LMF marker.

* [interp] Rethrow from the actual ip

Before we would rethrow from ip - 1 which could be part of another clause, screwing up EH.

* [interp] Enable all bcl disabled tests
2018-11-30 11:22:11 +02:00
monojenkins 7c01f6f583 [bcl] Update BCL Linked Size 2018-11-30 10:02:01 +01:00
Marek Safar da38380007 Bump linker 2018-11-30 09:55:14 +01:00
Marek Safar 7a8ae2dd27 Adds more tests 2018-11-30 09:55:14 +01:00
Marek Safar e07794921c [tools] Update linker arguments 2018-11-30 09:55:14 +01:00
Jay Krell c8b8a16e43 Get lasterror before messing with gc mode. (#11520) 2018-11-29 22:38:45 -08:00
Vlad Brezae 8e0cf9bcfb [tests] More test updates for interp/fullaotinterp (#11838)
* [tests] Include corlib suite on fullaotinterp

Disable more appdomain tests on fullaotinterp

* [interp] Bump again trampoline number for fullaotinterp

It wasn't enough for corlib and System.Core suites
2018-11-30 01:24:51 +02:00
Zoltan Varga 9c4f2281e2 [runtime] Use a separate implementation of mono-mmap.c for wasm, the default mmap based implementation doesn't work because munmap () cannot free memory inside mappings. (#11840) 2018-11-29 18:02:54 -05:00
Marek Safar 32beba680e [Facades] Updated netstandard facade 2018-11-29 22:04:37 +01:00
Jay Krell b1058550ed [Coop] Convert System_IO_DriveInfo. (#11519) 2018-11-29 12:54:27 -08:00
Martin Baulig 72ab774236 "Code Ultramarine": sync X509Certificate2 with CoreFX and introduce X509Certificate2ImplUnix (#9705)
Sync `X509Certificate2` implementation with CoreFX, similar to how we did for `X509Certificate` in "Blue" (#9650).

* Introducing `X509Certificate2ImplUnix` as new common base class for `X509CertificateImplApple`, `X509CertificateImplBtls` and `X509Certificate2ImplMono`.  This uses the internal `CertificateData` class from CoreFX instead of the old "fallback" implementation from "Mono.Security".

* `MonoBtlsProvider`, `X509CertificateImplBtls`: the "fallback" option has been removed since we now always provide this functionality via the managed `CertificateData`.

* `X509CertificateImplMono`: This has been largely stripped down to use the new `X509CertificateImplUnix`.
2018-11-29 21:20:29 +01:00
Jay Krell 2129059951 Fix some warnings. Mostly benign but driver.c looks maybe crashy. (#11843)
```
abcremoval.c: In function 'process_block':
abcremoval.c:1061:6: warning: variable 'inst_index' set but not used [-Wunused-but-set-variable]
  int inst_index;
      ^

driver.c: In function 'mini_regression_step':
driver.c:514:12: warning: 'func' may be used uninitialized in this function [-Wmaybe-uninitialized]
     result = func ();
            ^

aot-compiler.c: In function 'emit_method_info':
aot-compiler.c:6388:10: warning: variable 'method_index' set but not used [-Wunused-but-set-variable]
  guint32 method_index;
          ^

mini-codegen.c: In function 'mono_print_ins_index_strbuf':
mini-codegen.c:727:3: warning: format '%s' expects argument of type 'char *', but argument 3 has type 'gpointer' [-Wformat=]
   g_string_append_printf (sbuf, " %s", ins->inst_p1);
   ^
  CC       libmini_la-mini-exceptions.lo
mini-exceptions.c: In function 'summarize_frame':
mini-exceptions.c:1556:25: warning: unused variable 'ud' [-Wunused-variable]
  MonoSummarizeUserData *ud = (MonoSummarizeUserData *) data;
```

Probably from:
https://jenkins.mono-project.com/job/build-package-dpkg-mono-pullrequest/label=ubuntu-1404-amd64/326/console
2018-11-29 20:38:32 +01:00
Alexis Christoforides c8e3ba4e4e [driver] Parse config file under --regression mode also (#11845)
As of https://github.com/mono/mono/pull/11342 the regression tests (builtin-types.cs) call into System.Native incidentally as part of Interop.Sys type initialization. The --regression command line option was causing the --config part of the mono invocation to be ignored, resulting in a buried 'System.DllNotFoundException: System.Native' during the test run,
2018-11-29 13:55:16 -05:00
Alexander Köplinger eb53bbe805 [ci] Don't pass Helix API token for telemetry in PR builds 2018-11-29 18:45:11 +01:00
Ludovic Henry e8c423ec2b [sdks] Reduce android provisioning to minimum + Rework targets generation (#11835)
* [sdks] Reduce android provisioning to minimum

It's not in use by XA anymore, so we only care about what we require

* [sdks] Rework targets generation
2018-11-29 09:30:59 -08:00
Johan Lorensson 27d1568d21 Merge pull request #11786 from lateralusX/lateralusX/windows-llvm-60-windows-x64
Windows x64 LLVM 6.0 support.
2018-11-29 15:46:34 +01:00
Alexander Köplinger 8cb2c03352 [ci] Move Linux x64 C++ to Helix 2018-11-29 15:35:57 +01:00
Zoltan Varga 1337d2e044 [jit] Refactor call code. (#11775)
* [jit] Refactor the constrained call handling code into a separate function. NFC.

* [jit] Move the low level call related code to calls.c. NFC.

* [jit] Use mini_emit_get_rgctx_klass () in a few more places.

* [jit] Add calls.c to common_sources.

* Fix some c++-isms.

* Fix the windows build.
2018-11-29 09:18:37 -05:00
Rolf Bjarne Kvinge c93db5b047 [System] Refactor tests to use system-assigned ports whenever possible. (#11829)
Refactor tests to use system-assigned ports whenever possible, so that we
avoid the potential race condition in NetworkHelpers.FindFreePort.

This should make it much less probable to run into spurious "Address already
in use" exceptions.

In some cases I kept the call to NetworkHelpers.FindFreePort:

* When the test is not binding/listening on a port, but instead trying to
  connect to an inexistent port (for tests that verifies error handling /
  exceptions). In this case there is still a race condition (if a test tries
  to verify that a connection fails, it may unexpectedly succeed instead).

* Sometimes the test doesn't actually use the port (the test is verifying
  something very different, for instance a ArgumentNullExceptions, which are
  thrown before the port is used).

* Some API doesn't allow for requesting a system assigned port:

    * HttpListener: in this case I elected to re-try a few times in case of
      "Address already in use" exceptions.

    * The 'UdpClient (string, port)' constructor (other constructors work
      fine): these turned out a bit complicated to work around (or would
      modify the test more than would be reasonable), so for these we still
      have to hope for the best.

Hopefully fixes https://github.com/xamarin/maccore/issues/604.
2018-11-29 14:02:07 +01:00
Martin Baulig 374925522b [corlib]: Bring "HashAlgorithm" from CoreFX. (#11794) 2018-11-29 13:32:02 +01:00
Alexander Köplinger 9ebde410b5 [corlib] Disable AllEncodingsAreSerializable on mobile
We won't have all encodings on mobile by default.
2018-11-29 12:44:41 +01:00
lateralusX e4e30da77f Fix review feedback. 2018-11-29 10:42:05 +01:00
Egor Bogatov 787f1bc69c [NS2.1] Import some primitive System.Drawing types from CoreFX (#11658)
* Import Color and friends from CoreFX

* Fix some tests

* SystemColors.cs from CoreFX

* bump corefx

* ignore reflection tests

* fix System.Web tests

* bump corefx

* remove files

* fix mobile platforms

* fix mobile build

* fix mobile build

* fix mobile build

* fix mobile build

* Bump API snapshot submodule

* [csproj] Update project files
2018-11-29 09:12:32 +01:00
monojenkins 3b47ac2e9a [csproj] Update project files 2018-11-29 08:58:20 +01:00
Martin Baulig 89e599bc6f Misc corefx sources (ReadOnlyMemoryStream and CertificateHelper). 2018-11-29 08:58:20 +01:00
Egor Bogatov 1d0189d778 [corlib] Make all Encoding types serializable (#11661)
Fixes https://github.com/mono/mono/issues/11529 
Fixes https://github.com/mono/mono/issues/11663
2018-11-29 08:48:59 +01:00
Alexander Köplinger fab1f8e19b Update csproj 2018-11-29 02:30:49 +01:00
Calvin Buckley 5e08e6a1d4 Revert usage of gcc builtin for icache flush on ppc (#11815)
This is a no-op on gcc ppc for AIX, Linux, and FreeBSD, and should
not be used until gcc implements this. (It *does* on ARM, RISC-V,
Alpha, and MIPS, however - but not PowerPC or x86, based on a skim
of gcc source.)

Should fix #11527.
2018-11-28 20:04:55 +01:00
Rolf Bjarne Kvinge 212bfe90f1 [System] Use pid-specific X509Store names in tests to make it possible to run multiple System test runs in parallel. (#11830)
While working on PR #11829 I stress-tested the tests by running multiple test
runs in parallel, and it turned out that the X509StoreTest is not parallel-safe.

This fixes the X509StoreTest test to parallel-safe.
2018-11-28 19:20:34 +01:00
Marek Safar cd69b727d0 [build] Fixes documentation build profile dependency (#11801) 2018-11-28 17:47:59 +01:00
Alexander Kyte fb42448b70 [runtime] Integrate BenchmarkDotNet for in-tree microbenchmarks (reapply of #9833) (#11813) 2018-11-28 17:13:07 +01:00
Alexander Kyte aae4a8d8fc [runtime] Fix return of uninit value (#11823)
We have a return on line 3608 that doesn't have an
obvioius assignment to the variable "o" before that.
2018-11-28 10:41:10 -05:00
Vlad Brezae 53672c5f4c [interp] Enable System.Xml tests (#11791)
* [tests] Change timezone so it doesn't fail on UTC+2 systems

Change to remote UTC-1

* [interp] Enable System.XML tests
2018-11-28 07:19:08 -08:00
Jérôme Laban bcf63dcb9a Add the packager --search-path parameter (#11396)
- Adds the ability for the packager to search in additional folders when resolving assemblies.
- Ignore missing symbols when resolving assemblies, which can happen for facade assemblies.
2018-11-28 07:08:58 -08:00
Vlad Brezae aa8ea8026d [interp] Fix interp inline (#11824)
[interp] Fix interp inline


<!--
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-11-28 09:55:41 -05:00
Vlad Brezae 9cf13ee9e5 [interp] Enable System.Data tests on fullaotinterp (#11798)
* [interp] Enable System.Data tests on fullaotinterp

* [csproj] Update project files
2018-11-28 15:50:01 +02:00
Vlad Brezae e17958b140 [arm] Add enough trampolines for fullaotinterp mode (#11811)
Fixes a few bcl tests suites.
2018-11-28 15:19:09 +02:00
monojenkins 5514c173c3 [bcl] Update BCL Linked Size (#11819)
Size Diff: https://jenkins.mono-project.com/job/test-mono-mainline-bclsize/149/BCL_20Size_20Diff/

Commits since last run: 31b8fa1...8b605414d1f9eeff781ed0b4d628acd5287296b7
2018-11-28 12:33:51 +01:00
Martin Baulig f3706b57ee Move "NegotiateStreamPal" from "System.Data" into "System". (#11778)
Make System internals visible to System.Data and move some of the internal
GSS sources into System.
2018-11-28 12:29:04 +01:00
Maxim Lipnin 5cdc152df8 [corlib] Type from CoreFX (#11665)
Part of #7737
2018-11-28 12:00:50 +01:00
Alexander Kyte 892cad1dab Merge pull request #11790 from alexanderkyte/fixup_merp_exc_type
[crash] Add managed exception class name
2018-11-27 19:55:58 -05:00
Alexander Köplinger 8b605414d1 [ci] Add workaround for Helix SDK not setting external visibility on PRs when using authentication 2018-11-28 00:41:19 +01:00
Vlad Brezae 34781da14e [interp] Enable System.Web.Services tests on fullaotinterp (#11800) 2018-11-28 00:42:20 +02:00
Vlad Brezae 51b977699f [runtime] Check for error to prevent overwrites (#11812)
Fixes crash in corlib suite on fullaotinterp
2018-11-28 00:42:03 +02:00
Alexander Kyte 67f2491e77 [crash] Add managed exception class name 2018-11-27 14:50:03 -05:00
Alexander Köplinger 1f6c9272fe Revert "[runtime] Integrate BenchmarkDotNet for in-tree microbenchmarks (#9833)"
This reverts commit e15b8c53ff.

It broke other builds.

Revert "[bench] Revert hardcoding of microbenchmarks to run-jenkins (#11787)"

This reverts commit 7a81ac67a2.
2018-11-27 13:46:23 +01:00
lateralusX 6f987dd44d Bump to latest Mono LLVM commit to include needed Windows x64 changes. 2018-11-27 10:33:32 +01:00
monojenkins 0de674c2dc [csproj] Update project files 2018-11-27 09:21:34 +01:00
Marek Safar b7e8278eb5 Bump linker 2018-11-27 09:21:34 +01:00
Vlad Brezae 21f9aeeef4 [interp] Fix fullaotinterp exceptions (#11760)
* [interp] Check for exception if we always catch it in coop case

* [interp] Enable more fullaotinterp tests

billions and billions

* [interp] Reorganize tests for fullaotinterp

* [interp] Don't include internal frames in stack trace

For handled exceptions. On unhandled exceptions we leave them for debugging purposes.

Fixes exception18.cs
2018-11-27 10:20:41 +02:00
Alex Earl 2c4859839e Fix #11779
This adds any base interfaces to the remoting TypeInfo to match the
behavior of MS.NET
2018-11-27 09:05:51 +01:00
Alexander Köplinger 94d4055773 [ci] Disable log compression in pipeline builds for now - second attempt 2018-11-26 21:53:55 +01:00
Alexander Kyte 7a81ac67a2 [bench] Revert hardcoding of microbenchmarks to run-jenkins (#11787) 2018-11-26 12:38:15 -08:00
Alexander Kyte e15b8c53ff [runtime] Integrate BenchmarkDotNet for in-tree microbenchmarks (#9833)
Don't merge, using my fork of the BenchmarkDotNet repo so I can use a not-yet-merged hack to fix the build.
2018-11-26 12:34:26 -08:00
Alexander Köplinger fb4b611636 [ci] Disable log compression in pipeline builds for now
It is incompatible with JEP-210 at the moment.
2018-11-26 17:42:57 +01:00
Alexander Köplinger d4f2bc598c [ci] Bump nunit-lite submodule to fix csc warning 2018-11-26 17:24:55 +01:00
lateralusX 8548b21a92 Make used environment variables local to test scripts. 2018-11-26 17:24:35 +01:00
lateralusX 99eb69b14b Build additional LLVM backends and tools on Windows. 2018-11-26 17:23:39 +01:00
lateralusX c702820e14 Fix msvc build warnings. 2018-11-26 17:23:27 +01:00
lateralusX a2bf8b2a07 Fix assert under LLVM debug builds due to mismatched types.
When doing AOT build of builtin-types.exe using a debug compiled LLVM build the
following assert occurs:

Assertion failed: C1->getType() == C2->getType() &&
"Operand types in binary constant expression should match",
file C:\github\mono\external\llvm\lib\IR\Constants.cpp, line 1717.

This happens due to an optimization in cfold.c that removes the widening
done to a const variable in C:\github\mono\mono\mini\mini-native-types.c@224
and when that variable is later used in 64-bit LLVM lowering of OP_LNEG, OP_LNOT
they mismatch the static const 64-bit int used as operands triggering the assert.

Fix is to make sure the operand used when lowering these opcodes are converted
to matching operands.
2018-11-26 17:23:05 +01:00
lateralusX 6d0af3c44d Fix stack corruption when using nullable types in dyncall.
Incorrect calculation of start of nullable buffer caused stack corruption.
Currently this was only identified on Windows x64 due to use of alternative
ABI register storage types. Fix resolves crash in test_0_dyncall_nullable.
2018-11-26 17:22:50 +01:00
lateralusX 536cd702ed Fix LLVM linker flags for 6.0. 2018-11-26 17:22:31 +01:00
Zoltan Varga 99f9565d62 [runtime] Add stack marks to a few icalls. (#11774)
* [runtime] Add a mono_runtime_get_caller_from_stack_mark () function, use it in a few places. NFC.

* [bcl] Add a stackMark argument to AppDomain.Load () calls.
2018-11-26 16:52:49 +01:00
Bernhard Urban f396735a83 [mini] use AOT trampolines in interp mixed mode (#11767)
[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 08:55:42 -05:00
monojenkins 31b8fa1bc8 [bcl] Update BCL Linked Size 2018-11-23 09:10:27 +01:00
Zoltan Varga 53cc61669a [jit] ABCREM improvements. (#11761)
[jit] ABCREM improvements.
2018-11-23 02:45:33 -05:00
Zoltan Varga 53cf7bb3c6 [jit] Rename MONO_PATCH_INFO_INTERNAL_METHOD to MONO_PATCH_INFO_JIT_ICALL. (#11758) 2018-11-22 21:52:42 -05:00
Alexander Köplinger 59eba95b90 Add MKINSTALLDIRS for 4.7.1-api and 4.7.2-api
Not strictly necessary but for consistency.
2018-11-22 15:13:29 +01:00
Yvan Janssens e709b687b1 [aix/ibmi] Fix for PR#11704 (#11757)
@kadler addressed a mistake related to the difference between POWER5 and POWER5_ANDUP wrt. capabilities detection.

This PR should fix this. 

Context: https://github.com/mono/mono/pull/11704#discussion_r235525330
2018-11-22 13:11:07 +01:00
Aleksey Kliger 9ac5844ad4 [loader] ignore 'internalcall' impl attribute on 'abstract' methods
Otherwise we emit a noisy warning when doing a lookup of the method.

Fixes https://github.com/mono/mono/issues/11479
2018-11-22 09:52:08 +01:00
monojenkins 5419b07457 [bcl] Update BCL Linked Size 2018-11-22 09:51:25 +01:00
Zoltan Varga 7067ed1910 [corlib] Refactor Type:GetName () to reduce differences with refsources and make it easier to add support for stack marks later. (#11154)
* [corlib] Refactor Type:GetName () to reduce differences with refsources and make it easier to add support for
stack marks later.

Move the icall to RuntimeTypeHandle. Pass a unused stack mark and a unused reflectionOnly parameter.

* Bump API snapshot submodule
2018-11-22 02:56:01 -05:00
Vlad Brezae 765f462bb4 [interp] Add inlining of small methods (#11735)
[interp] Add inlining of small methods

Avoid call overhead by inlining small methods. We replace stinarg opcodes with storing of the arguments in locals allocated in the parent frame (for each argument).

TODO
- support for methods with locals
- maybe add inline costs to prevent over inlining

On microbenchmark inlining can improve up to 3.5x (less than the 5x that I observed with jit).

Contributes to #11531
2018-11-21 11:15:35 -05:00
Alexander Köplinger b6a2f252fc [tools] Fix build of mono-shlib-cop test.dll 2018-11-21 15:48:49 +01:00
monojenkins 1236b908a4 [bcl] Update BCL Linked Size 2018-11-21 09:50:24 +01:00
Zoltan Varga 8fee89e530 [WIP] [WASM] AOT work (#11746)
[bcl] Use the UTF8 encoding on WASM by default, similarly to ios.
2018-11-21 02:02:35 -05:00
Calvin Buckley d94c842496 System.Net.NetworkInformation.NetworkInterface backend for AIX (#9454)
Yes, I do know of a possible refactor, but why not get this working? This will enable `System.Net.Sockets.Socket` to depend IPv4/IPv6 are working, and thus, fix a LOT of issues on CI; a bunch of test suites have one or two things that depend on loopback, which is currently busted unless you nop out Socket's protocol check.

Also made a note that the Mac version of the backend is actually likelier to work under other OSes. Structures are kinda ugly, but they work; it took a whole morning and night beating them into submission.

Untested under PASE, though I've marked notes for self to what's different. (My guess: it works, but not as well as it should - but good enough so that Socket starts working again.)

And hey, the Mac backend can't do this!

```
csharp> NetworkInterface.GetAllNetworkInterfaces().Select(x => $"The MTU of {x.Name} is {x.GetIPProperties().GetIPv4Properties().Mtu}");
{ "The MTU of en0 is 1500", "The MTU of lo0 is 16896" }   
```
2018-11-21 03:11:17 +01:00
Alexander Köplinger 9cf3782449 [tests] Propagate runtime exit code in test_op_il_seq_point.sh (#11749)
We weren't checking whether the runtime returned a zero exit code which
means if the compilation failed we still reported success.

Now the exit code is propagated all the way up and we report an error
both to make and to the xml result file.

Since iltests.exe contains a test with expected invalid IL this would
now cause a failure. The easiest fix is to just move that test from
mono/mini to mono/tests since all other tests are fine.

Fixes https://github.com/mono/mono/issues/11091
2018-11-21 02:17:23 +01:00
Aleksey Kliger f63d97d384 [loader] Use Request structs to pass arguments to the loader
Try to make all entry points into the loader look more uniform by taking a request
struct instead of a big pile of arguments.  Where it makes sense, make the
structs subtypes of each other so that more general arguments are shared.

- Pass assembly load arguments in a struct
- Pass assembly open arguments in a struct
- Push MonoAssemblyOpenRequest creation to some callers
- Drop is_private argument to try_load_from
   It's been dead code for ten years since c9e8bac0c3
- Get rid of mono_assembly_open_a_lot
- Drop dead static function
- Replace mono_assembly_load_full_nosearch by mono_assembly_request_byname_nosearch
- replace mono_assembly_load_full_internal by mono_assembly_request_byname
- Make mono_assembly_request_byname the internal API
   pass a no_postload_search flag in MonoAssemblyByNameRequest, usually FALSE.
   Pass TRUE in the one caller of the old mono_assembly_request_byname_nosearch.
- Pass the requesting assembly via MonoAssemblyByNameRequest
- Prepare loader Requests with an initialization function
2018-11-20 18:45:20 -05:00
markusbeth 60d0977c65 prevent endless recursion in ListView.ToString() (#11049) (#11561)
prevent endless recursion in ListView.ToString()

do not access the Items[] in ListView.ToString() in VirtualMode
as this might cause an endless recursion if ToString() is called
from within the RetrieveVirtualItem event handler

Fixes #11049
2018-11-20 15:45:33 -05:00
Aleksey Kliger e9987df5bd [tests] Add some Type.IsByRefLike tests 2018-11-20 08:20:05 -05:00
Aleksey Kliger f20445ba0b [reflection] make t.MakeByRefType().IsByRefLike == False
Fixes https://github.com/mono/mono/issues/11693
2018-11-20 08:20:05 -05:00
Zoltan Varga d2028ba041 [arm64] Fix passing r4/r8 arguments on the stack in the gsharedvt trampoline. (#11741)
Fixes https://github.com/mono/mono/issues/11613.
2018-11-20 04:30:07 -05:00
Zoltan Varga 3241199830 [runtime] Initialize MethodBody objects by calling a ctor instead of accessing the object directly. This allows the MethodBody type to be removed by the linker. (#11730)
* [runtime] Initialize MethodBody objects by calling a ctor instead of accessing the object directly. This allows the MethodBody type to be removed by the linker.

* [bcl] Preserve CustomAttributeData and related types using PreserveDependency attributes on the GetCustomAttributesDataInternal () icall.

* Fix a test.

* Fix C++ build failures.

* Bump API snapshot submodule
2018-11-20 03:09:51 -05:00
Zoltan Varga c7a71ca4bd [WIP] [WASM] Ongoing AOT work. (#11728)
* [wasm] Add the declaring types assembly name to the mangled name for instances during dedup. Fixes failures when two assemblies have a generic type with the same name.

* [runtime] Rename MONO_WRAPPER_UNKNOWN to MONO_WRAPPER_OTHER.

* [aot] Make the aot name mangling a little denser.

* [wasm] Don't emulate lojg shifts/multiplications.

* [runtime] Fix warnings.

* [aot] Small cleanups to the dedup code:

* Fix the dedup logging in llvmonly mode.
* Split mono_compile_assembly () into 2 functions, the second one doing the emission.
* Split the setting of cfg->skip from emit_code ().
* Skip more code and some logging for the other assemblies in the dedup-include case.

* [jit] Do the conversion to JIT intrinsics somewhat earlier.

This is needed to avoid emitting the code for passing the mrgctx etc. for
generic intrinsics like RuntimeHelpers.IsReferenceOrContainsReferences ().

* [aot] Implement sharing of gsharedvt wrappers passing/receiving
valuetype arguments based on their layout.

This is done by replacing valuetypes with instances of the
newly added Mono.ValueTuple generic structures inside the
wrappers. For example, for the type:
struct FooStruct {
  int i; object o;
}
and the gsharedvt out wrapper:
gsharedvt_out (ref FooStruct v);

This will be replaced by:
gsharedvt_out (ref ValueTuple<int, object> v);

The two structures have the same layout so as far as the JIT is
concerned, they are identical.

* [aot] Share native int/native uint with int32/uint32 in gsharedvt wrappers on 32 bit platforms.

* [bcl] Make the Mono.ValueType structs internal.
2018-11-20 02:21:21 -05:00
Aleksey Kliger 90a3ca90a2 Bump corefx 2018-11-19 15:26:04 -05:00
Aleksey Kliger d3778a8b7c [reflection] Parse error if rank > 1 array contains *
Can either have a multi-dimensional array type or an array with a lower
bound, not both.  (eg `System.Int32[,,]` vs `System.Int32[*]`, but not `System.Int32[*,]`)

Fixes https://github.com/mono/mono/issues/11684
2018-11-19 15:26:04 -05:00
Ludovic Henry f1b7f3969b Revert " [sdks] Add mac-{mac32,mac64} and ios-tools64 targets" (#11734)
* Revert "[wasm][binding] Allow the cleanup of transparent/bridged marshalled objects causing leaks. (#11660)"

This reverts commit 75741eb68d.

* Revert "[wasm] Add the declaring types assembly name to the mangled name for instances during dedup (#11724)"

This reverts commit 63fb96c61a.

* Revert "[runtime] Skip sentry upload when tool fails to build (#11726)"

This reverts commit cb690285fb.

* Revert "[sdks] Add mac-{mac32,mac64} and ios-tools64 targets (#10964)"

This reverts commit 6f1537ef58.
2018-11-19 08:52:19 -05:00
Kenneth Pouncey 75741eb68d [wasm][binding] Allow the cleanup of transparent/bridged marshalled objects causing leaks. (#11660)
- Example: When a delegate is marshalled to JS it is allocated so that it is not GC'd.  Since we do not know when JS is finished with the delegate we need a way, for right now, to tell the Runtime to de-allocate the object and remove the transparent/bridged instance from JS as well.  The side-effect of not doing this is that any local that is captured (used) by a lambda became heap memory and were allocated as fields on the object.  Since the delegate is never a candidate for GC the local that was captured was never released either.

- Fix an error with Windows Edge and Windows IE that threw an exception `Object doesn't support this action` on certain host objects.  This only affected Windows Edge and IE when using the JavaScript delete operator to clean up an object after being disposed.

- Cleanup marshalled Tasks after completion.  The marshalled tasks and their continuation objects were never un-allocated thus not allowing them to be GC'd.
2018-11-19 13:08:07 +00:00
Zoltan Varga 63fb96c61a [wasm] Add the declaring types assembly name to the mangled name for instances during dedup (#11724)
Fixes failures when two assemblies have a generic type with the same name.
2018-11-19 13:55:18 +01:00
Alexander Kyte cb690285fb [runtime] Skip sentry upload when tool fails to build (#11726) 2018-11-19 13:54:24 +01:00
Ludovic Henry 6f1537ef58 [sdks] Add mac-{mac32,mac64} and ios-tools64 targets (#10964) 2018-11-19 13:52:34 +01:00
Alexander Köplinger 5e45e77fbf [ci] Use correct casing in Helix queue names 2018-11-19 13:20:28 +01:00
myfreeweb b60b724963 Add support for FreeBSD/aarch64 (#11638)
Add support for FreeBSD/aarch64

(I also needed the #7017 workaround and a boringssl patch for auxval stuff, but this is the important part.)
2018-11-19 06:25:31 -05:00
Ludovic Henry aa0d921232 [sdks] Add monotouch_tools profile + Add mono-api-info and pdb2mdb to monodroid_tools profile (#11707)
* [sdks] Add monotouch_tools profile

* [sdks] Add mono-api-info and pdb2mdb to monodroid_tools profile

* [csproj] Update project files
2018-11-18 22:58:54 -05:00
Alexander Köplinger f30ce1cbce [bcl] Add missed Helix tests for vts tests and System.Web.Extensions-standalone (#11720)
Missed those while converting the tests to Helix.
2018-11-17 01:35:59 +01:00
Egor Bogatov ab0736fa79 [NS2.1] IntPtr, UIntPtr, Encoding, Enum, Random, Thread, System.Net primitives (#11674)
* NS21: Encoding, Thread, UIntPtr, IntPtr, Enum, Random

* some http primitives

* undo Random

* add more Runtime tests

* bump corefx

* update tests

* Update corlib_xtest.dll.sources

* Bump API snapshot submodule

* [csproj] Update project files
2018-11-16 18:11:50 -05:00
Alexander Köplinger 6283c6337d Revert "[ci] Don't try sentry upload after a failed build"
This reverts commit 0853179237.
It's actually still useful in cases where the "build" profile worked but
a later profile crashed.
2018-11-16 21:29:58 +01:00
Alexander Köplinger 0853179237 [ci] Don't try sentry upload after a failed build
It won't work cause the uploader wasn't built yet.
2018-11-16 21:26:24 +01:00
Nikita Voronchev 1076d746b9 [WinForms] Matching Mono PropertyGrid behaviour with .Net one (#11618) 2018-11-16 14:29:43 -05:00
HebaruSan e743a7fd74 [WinForms] Really fix ToolStrip background (#11287)
## Problem

Even after #10942, menus and toolstrips still look awful with a dark theme:

![toolstrip](https://user-images.githubusercontent.com/1559108/46361551-8e6dea80-c633-11e8-97d1-242612b4b5cf.png)

## Previous attempt

#10942 was a first stab in the dark at what was going on here, before I managed to get mono to compile for testing. I was hopeful that it would address this, but the problem was different.

## Another red herring

Later I thought the problem might be that `SystemColors.ButtonFace.IsSystemColor` was `false`. It looked like this might have caused the runtime to interpret `ButtonFace`'s special 168 value as an RGB code instead of a system color marker.

This fix had no effect (see below for true cause), but I'll include it anyway; the lower bound of the upper system colors block needs to decrease from 170 to 168 to allow `ButtonFace` and `ButtonHighlight` to be considered system colors:

https://github.com/mono/mono/blob/44db64c620c2c957a49b3f5a69cb09c19c1c8c1a/mcs/class/System.Drawing/System.Drawing/KnownColor.cs#L200-L203

## Actual cause

The toolstrip color comes from `ProfessionalColorTable.ToolStripGradientBegin` and `ProfessionalColorTable.ToolStripGradientEnd`. The latter color is hard coded to a light shade, but the former defaults to `SystemColors.ButtonFace`.

These are the colors that are loaded from the GTK system theme:

https://github.com/mono/mono/blob/b104565ccfde477fc7b6308f2d3e4efff0af5848/mcs/class/System.Windows.Forms/System.Windows.Forms/X11DesktopColors.cs#L111-L116

Note that `ButtonFace` is not among them. This means that it uses a compile time default, and is not a good choice for the background of a control. `ToolStrip` is using it anyway, but other controls use `SystemColors.Control` instead.

## Changes

There are two obvious ways to fix this:

1. Use `SystemColors.Control` instead of `SystemColors.ButtonFace` in `ProfessionalColorTable`
2. Load `SystemColors.ButtonFace` from the system theme

This pull request does both. In addition, it also sets the other end of the toolstrip gradients to `SystemColors.ControlLight` instead of a hard coded value. The choice of `ControlLight` was made because in those cases where alternate hard coded values were available for both sides of the gradient, the "other" side was consistently lighter. Now it looks better:

![image](https://user-images.githubusercontent.com/1559108/47258840-efd0ee80-d466-11e8-842f-2fed8b3b9d82.png)
2018-11-16 20:09:20 +01:00
HebaruSan 89b1b8d049 Draw menu background with SystemColors.Menu to fix dark themes (#11301)
## Problem

Dropdown menus have light text on a light background in a dark theme:

![image](https://user-images.githubusercontent.com/1559108/47260376-2e26d780-d480-11e8-8330-86ecc82994df.png)

## Cause

The background is rendered here:

https://github.com/mono/mono/blob/4a6b11577fe06a58e6326b1c3a3bb58cfee6185c/mcs/class/System.Windows.Forms/System.Windows.Forms/ToolStripProfessionalRenderer.cs#L372-L375

`this.ColorTable.ToolStripDropDownBackground` is set to either `SystemColors.Window` or various hard coded shades of near-white in `ProfessionalColorTable`.

## Changes

Now that color comes from `SystemColors.Menu`, defined as "[Gets a Color structure that is the color of a menu's background](https://docs.microsoft.com/en-us/dotnet/api/system.drawing.systemcolors)", which looks better in a dark theme:

![image](https://user-images.githubusercontent.com/1559108/47260394-77772700-d480-11e8-85ad-03be8a59e56e.png)

It still looks fine in a normal theme as well:

![image](https://user-images.githubusercontent.com/1559108/47260396-7cd47180-d480-11e8-8989-4ee9448e9d05.png)

KeePass is not affected by this change, presumably thanks to its custom toolstrip renderer.
2018-11-16 20:07:55 +01:00
Aleksey Kliger (λgeek) be9a2f6303 [threading] Implement 'pulse' transition for two-phase STW (#11708)
* [threading] Add `pulse` transition and begin_pulse_resume_and_request_suspension operation.

A `pulse` atomically resumes a preemptively suspended GC Safe thread and
requests that it suspend again.

If the thread reaches a GC Safe -> GC Unsafe transition, it will self-suspend.
If it doesn't, another iteration of the 'mop up' STW phase will async suspend
it again.

* [threading] Use pulse_resume_and_request_suspension in STW

With non-hybrid suspend, a pulse is just a resume.

With hybrid suspend, a `pulse` is a combination of a resume of a preemptively
suspended GC Unsafe thread and a request that it suspend again - as if we
atomically resumed the thread and then applied the initial phase of two-phase
suspend again.  If the now-running thread comes to a GC Safe -> GC Unsafe
transition it will suspend.  If not, we will preemptively suspend it again
during the mop-up phase.

The important thing is that we don't want the thread to transition to GC Unsafe
again: if it does so, it may try to take a lock that some other
async-suspended thread is holding, and it will never reach a safepoint ---
exactly the situation that two-phase suspend is supposed to solve.

* [threads] Add mono_threads_is_multiphase_stw_enabled

Flip the logic in mono_thread_info_begin_pulse_resume_and_request_suspension
2018-11-16 12:47:45 -05:00
Alexander Köplinger 30ad7cde21 [upload-to-sentry] Skip reading assemblies without mono_crash.json and silence no symbols error (#11696)
The previous code read all the .dll and .exe files even when there actually wasn't any mono_crash.*.json file to process.

In the happy case of no crash file this cuts the time from 60s to 5s.

We can also use more efficient patterns in Directory.GetFiles() instead of getting _all_ files and filtering in-memory.

Lastly we also ignore printing a message when a debug symbols file wasn't found for an assembly, this is an expected case for a lot of our assemblies.
Using InMemory Cecil reading shaves another 20s off.
2018-11-16 16:46:37 +01:00
Bernhard Urban 5ed1bf1a52 [interp] attempt to intrinsify again after a method is resolved regarding generics (#11712)
[interp] attempt to intrinsify again after a method is resolved regarding generics

discovered when running https://github.com/Clancey/gMusic
2018-11-16 10:05:43 -05:00
Yvan Janssens 2cad522dcd [aix/ibmi] Build broken due to subtle difference between i and AIX
PASE is the Unix subsystem of IBM i, and is binary compatible with AIX. Since IBM i is not a Unix, there are some subtle differences between both environments.

There is an issue with the way PASE on IBM i 7.2 behaves differently than AIX with regards to the POWER_n_ANDUP defines for CPU compatibility. When trying to build on i as opposed to AIX, the following errors appear which break the build:

```
make[5]: Entering directory '/home/YVANJ/mono-on-i/mono/mono/utils'
  CC       libmonoutils_la-mono-hwcap-ppc.lo
mono-hwcap-ppc.c: In function 'mono_hwcap_arch_init':
mono-hwcap-ppc.c:67:6: error: implicit declaration of function '__power_4_andup' [-Werror=implicit-function-declaration]  if (__power_4_andup())
      ^~~~~~~~~~~~~~~
mono-hwcap-ppc.c:67:2: warning: nested extern declaration of '__power_4_andup' [-Wnested-externs]
  if (__power_4_andup())
  ^~
mono-hwcap-ppc.c:69:6: error: implicit declaration of function '__power_5_andup' [-Werror=implicit-function-declaration]  if (__power_5_andup())
      ^~~~~~~~~~~~~~~
mono-hwcap-ppc.c:69:2: warning: nested extern declaration of '__power_5_andup' [-Wnested-externs]
  if (__power_5_andup())
```

This commit adds `#ifdef`s to handle this condition so the build works on IBM i 7.2 now. The resulting application code should not differ from the AIX output, however, this patch fixes the build failure.
2018-11-16 14:56:36 +01:00
Alexander Köplinger a8b06539d5 [corlib] Fix xunit tests build for System.Reflection.TestModule.dll
test_lib_dir is only defined after the library.make include so we need
to move the logic further down.

Additionally we don't even need to build this assembly ourselves since
corefx already contains a prebuilt binary.
2018-11-16 14:31:02 +01:00
Mads Kruse Johnsen 7f5e358971 [wcf] do not assume that message body is always Wrapped (#11694)
Currently, setting IsWrapped=false on a MessageContract leads to an error in serialization due to an empty element being present where the wrapper element would have been, instead of it being gone entirely.
The serialization then fails because the empty string is not valid localName (which of course is fine).
2018-11-16 12:31:00 +01:00
Bernhard Urban 30bb12fa2a [aot] image is usable without debug flag when interpreter is used (#11705) 2018-11-16 12:14:52 +01:00
Johan Lorensson 71418eb6b0 Merge pull request #11666 from lateralusX/lateralusX/windows-llvm-support
Integrated LLVM build as part of Visual Studio Mono runtime build.
2018-11-16 07:59:59 +01:00
Alexander Kyte 7b3a6a4579 [crash] Remove duplicated il_offset (#11700) 2018-11-15 23:22:58 +01:00
Alexander Köplinger 178696df1c Fix tarball build
The helix binaries weren't getting included so the uploader tool failed to build.
While we don't need them for a tarball build it's easier to just include them.
2018-11-15 20:08:39 +01:00
Maxim Lipnin 462bd6781e [Reflection] CoreFX import for Module type (#11577)
* [Reflection] CoreFX import for Module type

* Bump corefx

* Fix incorrect merge

* Bump corefx

* Update corlib_xtest.dll.sources

* Revert corert bump

* Bump corert

* Bump xunit-binaries

* Use NotImplemented.ByDesign

* Remove redundant class modificators

* Make the output for TestModule.dll assembly profile specific

* Update path to include TestModule.dll assembly

* Bump API snapshot submodule

* [csproj] Update project files
2018-11-15 13:19:01 -05:00
Alexander Köplinger 041c2d0d66 [bcl] Remove unused DISABLE_CAS_USE and AGCLR define (#11695)
* [bcl] Disable unused DISABLE_CAS_USE and AGCLR define

* [csproj] Update project files
2018-11-15 17:26:33 +01:00
Aleksey Kliger (λgeek) 9fb668bfc8 [configure] Pass -stdlib=libc++ to clang on darwin to build C++ code (#11673)
[configure] Pass -stdlib=libc++ to clang on darwin to build C++ code

On iOS 6.0 (`-miphoneos-version-min=6.0`), this is needed to get modern C++11
headers like `<type_traits>`.  It does not seem to harm anything to
over-approximate and pass it to clang always when building on Darwin.
2018-11-15 10:56:37 -05:00
Zoltan Varga 83fd9e41f0 [runtime] Fix the size calculation in mono_debug_add_method (). (#11672) 2018-11-15 16:10:19 +01:00
Jonathon Rossi 0cdb35fa47 Fix starting process with empty environment incorrectly inherits all variables (#11630)
This pull request fixes starting a process with an empty environment variable collection in `ProcessStartInfo`. As per the issue it fixes a regression that it used to work but currently an empty environment variable collection works like it was never touched.

I also made a minor fix to remove the `StringBuilder` because a simple `string.Concat` does the job without the `StringBuilder` allocation and overhead.

I've included unit tests. Please let me know if you'd like any changes.

Fixes #8766
2018-11-15 16:06:26 +01:00
Rodrigo Kumpera aa50145d12 [metadata] Compute interface offsets of ginst by inflating the GTD instead of doing it from the grounds up. (#10931)
* [metadata] Compute interface offsets of ginst by inflating the GTD instead of doing it from the grounds up. Fixes #10837

Say you have;
```
interface Bar<T> { T Bla(); }
class Foo<A,B>: IBar<A>, IBar<B> {
	int IBar<int>.Bla)() { ... }
}
```

The GTD of Foo will have the following interface offsets table:
```
4: IBar<A>
5: IBar<B>
```

With the existing code, if you have Foo<int,int> the interface offsets table will look like this:
```
4: IBar<int>
```

The problem with that is it will produce a hole in the vtable and subclasses of Foo<int,int> will have not on slot 5.

That would be just wasteful, unless you have this:

```
class Sub: Foo<int,int>, IBar<int> {
	int IBar<int>.Bla)() { ...  }
}
```

IOW, a subclass that overrides the interface implementation in Foo. The problem is that it's not always reliable to which iface offset
calls to `IBar<int>` will go through and thus it's possible to have calls made against instances of `Sub` to execute the code from its base
class.

The solution is to inflate the interface offsets table from the gtd as that will preserve the number of entries and will cause the
rest of the vtable layout code to fill the duplicated slots correctly.

* Add regression test for #10837.

* [sre] Replace assert with proper error handling.

* [metadata] Don't mono_class_init ifaces, just have offsets setup.

* [metadata] Make setup_interface_offsets not depend on mono_class_init and fix lazy iid computation.

All that interface offset setup needs are iid as the output in interfaces_packed is sorted by it. Remove
the need to use mono_class_init by properly extracting and making iid setup lazy.

Beyond that, make mono_get_unique_iid not return 0 as a valid iid.
Otherwise we don't have a proper sentinel value when lazily computing iid.

* [metadata] Keep interfaces in the same relative order when computing offsets

qsort() is not guaranteed to be a stable sort (one that keeps elements with the
same key in the same order).  For example, the msvc qsort isn't stable.

Add an insertion_order field to ClassAndOffset to keep interfaces with the same
interface_id in the same relative order.

This is all relevant because in setup_interface_offsets we could see the same
interface multiple times (for example, with generics) at different offsets.
2018-11-15 07:39:06 -05:00
Alexander Köplinger 90c80dd026 [ci] Use "Build" as the queue name for Helix telemetry events 2018-11-15 01:50:21 +01:00
roozbehid 8b4f331e1d [wasm] add IIIIIIIIIIIII signature to managed2native transitions (#11659)
* add more calling up to 12 arguments

* use m2n-gen to generate it. also more cases which I encountered were added

* remove duplicate cookie
2018-11-14 17:46:47 -05:00
Alexis Christoforides 10c7e9f722 [System] Add FSEvent FileSystemWatcher to 'monotouch' BCL profile (#10809)
* [System] Add FSEvent FileSystemWatcher to 'monotouch' BCL profile

* [csproj] Update project files
2018-11-14 08:55:31 -05:00
Zoltan Varga eddc1d3990 [wasm] Rename the cross targets so 'wasm-cross' builds the 64 bit compiler, and 'wasm-cross-32' builds the old 32 bit version. (#11678) 2018-11-14 08:42:28 -05:00
Mads Kruse Johnsen 0ade173b9b [wcf] pass on the ContentType of MTOM message response (#11664) 2018-11-14 11:50:48 +01:00
Martin Baulig 1b02237c8f [System.Data]: GSS is not available on tvOS and watchOS. (#11671)
* [System.Data]: GSS is not available on tvOS and watchOS.

* [csproj] Update project files
2018-11-14 11:09:05 +01:00
lateralusX e6123028ae Fix scenario before cygconf.h has been created in build-init. 2018-11-14 09:42:44 +01:00
Zoltan Varga 930fa40957 [wasm] Ongoing AOT work. (#11637)
[wasm] Ongoing AOT work.
2018-11-14 00:25:39 -05:00
Ludovic Henry 5187b0bdaa [sdks] Compile support/{zlib-helper,nl}.c so XI/XM/XA does not have to cherry-pick them (#11599)
* [sdks] Compile support/{zlib-helper,nl}.c so XA doesn't have to cherry-pick it.

* [sdks] Fix ios and android compilation and use of tests

The tests are already built as part of the archive, so there is no need to recompile them. We just need to pick them from the right folder.
2018-11-13 22:06:04 -05:00
Vlad Brezae 6b858ef9d7 [interp] Small fixes (#11667)
[interp] Small fixes


<!--
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-11-13 19:05:36 -05:00
Mikayla Hutchinson c2b6caf04d Add meaningful resource strings for System.Web.Services (#11624)
* Add meaningful resource strings for System.Web.Services

Generated from mcs/class/referencesource/System.Web.Services/System.Web.Services.txt
using resx2sr

Also adds support for txt files and custom class names to resx2sr

Fixes #11623

* [csproj] Update project files

* [resx2sr] fix formatting

* [resx2sr] fix formatting

* [resx2sr] fix formatting

* [resx2sr] fix formatting

* [resx2sr] fix formatting
2018-11-13 17:04:54 -05:00
Alexander Köplinger 67ed831661 [ci] Add sentry upload to run-test-helix.sh too 2018-11-13 22:19:34 +01:00
Alexander Köplinger b429e290e8 [ci] Use different way of cleaning acceptance-tests/external
Some jobs pre-clone repositories into acceptance-tests/external, those
would be removed. We don't need to do that, all we want is to have
clean submodule repos so just cd into the repos and clean them.
2018-11-13 21:40:06 +01:00
Alexander Köplinger d4952011ea [ci] Remove MONO_HELIX_CREATOR and v4 suffix and fix sentry upload on build error
Setting the creator isn't needed, Helix defaults to using the API key user.
2018-11-13 21:02:31 +01:00
Alexander Köplinger 14e1e717ae [System.Web] Add optional shared FileSystemWatcher's to CacheDependency
Right now we create a separate FileSystemWatcher for each file in
CacheDependency. On systems where inotify handles are limited this
leads to problems. As a workaround we can share the FSW which watches
the same directory. Since this wasn't extensively tested, hide it behind
and environment variable.

We enable this in the Helix environment only for now.
2018-11-13 21:02:31 +01:00
Alexander Köplinger c408741000 [ci] Add targets to bundle tests and add a script to run them in Helix
The test-bundle target copies all assets needed for test execution
to a specified directory. We upload this directory to Helix and use it
to run our mainline tests.
2018-11-13 21:02:31 +01:00
Alexander Köplinger dcc2d172e9 [tools] Add client for sending jobs to Helix
This uses the Helix SDK to create jobs in the Helix environment.
2018-11-13 21:02:31 +01:00
Bernhard Urban 43b5f8c3ae [mini] rename s/__mono_ilp32__/MONO_ARCH_ILP32 (#11652) 2018-11-13 09:50:24 -05:00
Bernhard Urban 81924df99a [arm] fix --enable-minimal=aot build (#11653)
[arm] fix --enable-minimal=aot build

mentioned here: https://github.com/mono/mono/issues/8430#issuecomment-437041383
2018-11-13 09:45:44 -05:00
lateralusX ab33926c89 Fix LLVM install target in Visual Studio build. 2018-11-13 15:39:28 +01:00
Alexander Kyte 672249512b [sentry] Gracefully handle protocol version mismatches (#11655) 2018-11-13 15:18:50 +01:00
lateralusX de5b6bb8d1 Re-enable Ninja build for Visual Studio LLVM. 2018-11-13 14:59:30 +01:00
lateralusX 2ba737914e Use one msbuild worker as default for LLVM/BTLS Visual Studio build. 2018-11-13 14:44:52 +01:00
lateralusX 0227590612 Enable Win32 path variable when using with-llvm on cygwin. 2018-11-13 14:40:13 +01:00
lateralusX cca5d0d0f4 Reduce default LLVM/BTLS Visual Studio build output. 2018-11-13 14:38:49 +01:00
Neale Ferguson b7adce8049 Simplify retrieving TLS offset 2018-11-13 11:08:19 +01:00
Bernhard Urban 8e10108d9f [wasm] add ILI signature to managed2native transitions (#11646)
[wasm] add ILI signature to managed2native transitions

Mentioned here https://github.com/mono/mono/issues/8711#issuecomment-437764245
2018-11-12 20:15:33 -05:00
Alexander Köplinger 49a5af74f7 [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.
2018-11-13 00:19:07 +01:00
Alexander Köplinger 3a4c3e8cee [ci] Don't show apidiff/csproj diff step if it's not executed 2018-11-12 18:33:57 +01:00
Alexander Köplinger 2edec383b5 [ci] Move sentry reporting to the run-test-* scripts
So a "no-tests" build doesn't try to do sentry uploading.
2018-11-12 17:59:50 +01:00
lateralusX 9728edf5cc Align LLVM/BTLS Visual Studio external builds. 2018-11-12 16:28:23 +01:00
Alexander Köplinger d901e8ab9c [ci] Move apidiff and csproj diff out from run-test-default.sh
Due to new Jenkins job layering.
2018-11-12 15:27:35 +01:00
lateralusX 269d02cf5b Add support for LLVM integrated build as part of Visual Studio solution
build. LLVM build follows similar pattern as BTLS build and will be build
as part of regular Visual Studio build Mono runtime if LLVM has been enabled
through the autogen.sh, --enable-llvm or –with-llvm argument. It is also
supports msbuild properties MONO_ENABLE_LLVM, MONO_EXTERNAL_LLVM_CONFIG,
if Visual Studio Mono runtime has been built without using autogen.sh.
When just using –enable-llvm, LLVM build will try to build internal LLVM
branch under external/llvm or if override has been set in props file
(using MONO_INTERNAL_LLVM_SOURCE_DIR), an alternative LLVM source
directory path. If –with-llvm has been used pointing to an llvm-config.exe,
no internal LLVM will be build, but the external LLVM build will be used.
Needed LLVM executables (opt.exe, llc.exe) will be installed into regular
Visual Studio Mono runtime build output directory.

The internal Mono LLVM 6.0 release will build as part of changes to this
commit, but it has not yet been fixed to work as expected during runtime.
That work will be done in different commit. The Mono LLVM 3.6 branch will
however work as expected for Windows x64 and can be setup and used using
–with-llvm argument or build as part of Visual Studio build Mono runtime
by enabling msbuild properties, MONO_ENABLE_LLVM and
MONO_INTERNAL_LLVM_SOURCE_DIR.
2018-11-12 15:16:14 +01:00
Bernhard Urban 207a67ae22 [ios] cosmetic fix for WatchOS Makefile (#11639)
It's not really used, and the directory `[...]/SDKs/WatchOS.sdk` always
exists.
2018-11-11 22:02:22 -05:00
Bernhard Urban 06e00cd38d [wasm] add DDI signature to managed2native transitions (#11642)
Mentioned by a user here: https://github.com/mono/mono/issues/8711#issuecomment-437638741
2018-11-11 22:00:48 -05:00
Kenneth Pouncey 521b8a0b3c [wasm] Make WasmHttpMessageHandler the default handler for WebAssembly (#11631)
* Clean up leaks in the WasmHttpMessageHandler.

- Most of the leaks present themselves during a Cancel of a streaming request.

* Make WasmHttpMessageHandler the default handler for WebAssembly

-  Required libraries WebAssembly.Net.Http.dll and WebAssembly.Bindings.dll.

* Clean up spacing
2018-11-11 22:00:18 -05:00
Alexander Köplinger 5d2525527e Add common "test" target for precompiling test assemblies (#11622)
So we can precompile all tests across the repo using a simple "make test" in the root.
2018-11-12 00:37:11 +01:00
Bernhard Urban 95a26ebff9 [mini] rename INTERP_FILTER_METHOD to REGRESSION_FILTER_METHOD and accept it for all execution engines (#11594)
So this is possible now:

```console
$ REGRESSION_FILTER_METHOD=test_0_return ./mono/mini/mono-sgen --single-method=inline ./mono/mini/basic.exe
$ # or
$ REGRESSION_FILTER_METHOD=test_0_return ./mono/mini/mono-sgen --regression --interp ./mono/mini/basic.exe
```
2018-11-09 21:59:36 -05:00
Marek Safar 02e71d52de More codeowners updates 2018-11-09 21:14:03 +01:00
Henric Müller 037c8be1b6 Bumping reference assemblies generated with latest GenAPI (#11628)
This PR bumps the reference assemblies submodule to bring in private dummy fields in structs and should fix #7859.
2018-11-09 14:34:08 +01:00
Henric Müller 79820d638d Updating GenAPI binaries (#11629)
Bumping api-snapshot submodule which brings in a newly
built GenAPI binaries along with a rename of the exe
to Microsoft.DotNet.GenAPI.exe
2018-11-09 14:32:40 +01:00
Kenneth Pouncey 2bdadca909 Clean up leaks in the WasmHttpMessageHandler. (#11616)
- Most of the leaks present themselves during a Cancel of a streaming request.
2018-11-09 07:14:22 -05:00
monojenkins da2646c366 [bcl] Update BCL Linked Size 2018-11-09 09:50:52 +01:00
Bernhard Urban 43c37db845 [llvm] bump for armv5 fix (#11621)
[llvm] bump for armv5 fix

Commit list for mono/llvm:

* mono/llvm@76f65d611f Merge pull request #17 from lewurm/armv5-fix
* mono/llvm@a864c603a2 [mono] respect FloatABIType, so it will work on armv5

Diff: https://github.com/mono/llvm/compare/c97510286a58f9aaa116fcfdb8b693d5f61910d2...76f65d611fbf31890d79fd278e89cd889bf1c497
2018-11-09 02:25:36 -05:00
Zoltan Varga d768d8a571 [runtime] Add __attribute__(format) to glib string formatting functions, fix -Wformat warnings/errors exposed by the change. (#11611)
[runtime] Add __attribute__(format) to glib string formatting functions, fix -Wformat warnings/errors exposed by the change.
2018-11-08 15:15:39 -05:00
Zoltan Varga af0191cde0 [interp] Add a null check to MINT_LDELEMA. (#11606)
Fixes https://github.com/mono/mono/issues/11603.
2018-11-08 13:41:47 -05:00
Bernhard Urban a8a7a3401a [llvm] bump for armhf callingconv fix (#11607)
Commit list for mono/llvm:

* mono/llvm@c97510286a [mono] respect hardfloat/softloat setting in ARM ABI (#16)

Diff: https://github.com/mono/llvm/compare/8415fd85ce1570d4ba0a735bc4e968735a67ca37...c97510286a58f9aaa116fcfdb8b693d5f61910d2


Fixes https://github.com/mono/mono/issues/11095
2018-11-08 13:36:00 -05:00
Calvin Buckley 6d1b2316b8 Fix wasm mono showing print dialog twice on error (#11602)
Fixes #11596.
2018-11-08 13:36:01 +01:00
Marek Safar 3d47946343 [corlib] Removes dead code from EventInfo (#11502) 2018-11-08 12:58:05 +01:00
Marek Safar 46b36bf842 [sdks] Document one more build setting 2018-11-08 12:32:20 +01:00
Marek Safar df6056cd63 [corlib] Move Stack and Queue to mscorlib as we want to used them by (#11511)
* [corlib] Move Stack and Queue to mscorlib as we want to used them by

implementation code in mscorlib

* Bump API snapshot submodule

* [csproj] Update project files
2018-11-08 12:17:07 +01:00
Rodrigo Kumpera f5cb39880a unbreak the interp build. 2018-11-08 10:52:47 +01:00
Marek Safar 30e2d0974d [wasm] Move bundled linker to different location
Right now it's in same location as wasm implementation assemblies
which means they are used for execution but they are not .NET desktop
compatible.
2018-11-08 09:43:59 +01:00
Zoltan Varga ec545dcfd5 [wasm] Avoid referencing aot-dummy.dll in non-aot mode. (#11600) 2018-11-08 01:44:24 -05:00
Bernhard Urban e8aa7a2b73 initial RISC-V support (#11593)
initial RISC-V support

I rebased @alexrp's work (https://github.com/alexrp/mono/commits/riscv) and added stubs so this minimal example works in the interpreter:

```console
$ qemu-riscv64 ./mono/mini/mono-sgen --version
Mono JIT compiler version 5.21.0 (riscv/f4802305009 Wed Nov  7 02:58:20 PST 2018)
Copyright (C) 2002-2014 Novell, Inc, Xamarin Inc and Contributors. www.mono-project.com
        TLS:           __thread
        SIGSEGV:       normal
        Notifications: epoll
        Architecture:  riscv64,double-fp
        Disabled:      none
        Misc:          
        Interpreter:   yes
        Suspend:       preemptive
        GC:            sgen (concurrent by default)
$ export MONO_PATH=../mono-riscv-bclbuild/b/lib/mono/4.5 
$ grep -A 2 test_0_return mono/mini/basic.cs
        public static int test_0_return () {
                return 0;
        }
$ INTERP_FILTER_METHOD=test_0_return qemu-riscv64 ./mono/mini/mono-sgen --interp --regression basic.exe
Test run: image=/home/lewurm/work/mono-riscv/basic.exe
Results: total tests: 1, all pass 
Elapsed time: 0.002441 secs (0.002441, 0.000000)

Overall results: tests: 1, 100% pass
```
2018-11-07 15:04:00 -05:00
Zoltan Varga f0fe3fc426 [corlib] Move the runtime internal state to MonoModule from Module. Bump corlib version. (#11586) 2018-11-07 19:44:50 +01:00
Alexander Köplinger ab9c940dff [android sdk] Package resource assemblies into app bundle (#11583)
.NET resource assemblies live in subdirectories named after the culture
of the resource. We need to package these assemblies too.

Follow up to https://github.com/mono/mono/pull/11575
2018-11-07 13:42:06 -05:00
Zoltan Varga e14d92437e [jit] Move a few DISABLE_JIT stubs to arch-stubs.c. (#10991) 2018-11-07 13:41:07 -05:00
Alexander Köplinger 993f9bb39d Upgrade xunit to version 2.4 (#11595)
It contains the fix for a bug which makes NUnit xml parsing fail on Jenkins
2018-11-07 17:06:00 +01:00
Alexander Köplinger 5eb4698bb2 Bump corert 2018-11-07 13:28:27 +01:00
Marek Safar bc27aa23b7 Updates codeowners (#11592) 2018-11-07 13:06:46 +01:00
Alexander Kyte 5e318afd2e [runtime] Fix llvm arm autodetection / fix build (#11172)
[runtime] Fix llvm arm autodetection / fix build
2018-11-07 04:35:46 -05:00
monojenkins 5753014eed [bcl] Update BCL Linked Size 2018-11-07 09:34:15 +01:00
Alexis Christoforides 46a28303e2 [corlib] Import System.IO.Stream/BufferedStream from CoreFX (#10880)
* [corlib] Import System.IO.Stream/BufferedStream from CoreFX

* Bump API snapshot submodule

* [csproj] Update project files
2018-11-06 23:54:19 -05:00
Bernhard Urban 22143c7916 [icalls] remove DISABLE_POLICY_EVIDENCE (#11565)
[icalls] remove DISABLE_POLICY_EVIDENCE

Originally it was introduced with https://github.com/mono/mono/commit/db3591bb93dfe913c39ff73b95194effb88c880a . 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. Note that the definitions are available to the AOT compiler.

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 icalls definitions at run-time available too (via the optional icall table that is linked in, so no additional cost for the fullAOT runtime due to this change).

Also remove `HANDLES_MAYBE` since it isn't needed anymore.

I think eventually we want to have `--enable-minimal=policy_evidence` that _also_ excludes the actual icalls, but this will need changes on the BCL side as well.
2018-11-06 15:55:48 -05:00
Alex Earl 5d5d8fc7ea Bump roslyn-binaries submodule to pull in System.Xml.dll file name fix in vbc.rsp (#11573) 2018-11-06 21:40:40 +01:00
Zoltan Varga 7356b0914a [sdks] Exit with non-zero exit code if the simulator test fails on ios. (#11547) 2018-11-06 20:48:06 +01:00
Alexander Köplinger 30e870b19e [ios sdk] Package resource assemblies into app bundle (#11575)
.NET resource assemblies live in subdirectories named after the culture
of the resource. We need to package these assemblies too.

Addresses https://github.com/mono/mono/pull/11547#issuecomment-435688914
2018-11-06 19:43:09 +01:00
Bernhard Urban 2f749688f7 [interp] enable delegate-with-null-target.exe (#11570)
It was fixed by https://github.com/mono/mono/pull/11433

Related: https://github.com/mono/mono/issues/6861
2018-11-06 11:18:15 -05:00
Egor Bogatov 14cb53030d Don't override default LLVM's opt & llc args via llvmopts-add and llvmllc-add commands (#11556)
Don't override default LLVM's opt & llc args via llvmopts-add and llvmllc-add commands

Currently we can pass custom arguments to LLVM's `opt` and `llc` via:
```
mono --aot=llvm,llvmopts="...",llvmllc="..."
```
but those completely override the default arguments mono uses (some of them are required).
E.g. lets say I need to add `-foo` to both opt and llc, I should do:

```
mono --aot=llvm,llvmllc="**-foo** -march=x86-64 -mattr=sse4.1 -asm-verbose=false 
-disable-gnu-eh-frame -enable-mono-eh-frame -mono-eh-frame-symbol=_mono_aot_p_eh_frame 
-disable-tail-calls -no-x86-call-frame-opt -relocation-model=pic 
-filetype=obj,llvmopts="**-foo** -O2 -disable-tail-calls"
```

So this PR introduces new commands `llvmopts-add` and `llvmllc-add` to be able to simply do:
`mono --aot=llvm,llvmopts-add="-foo",llvmllc-add="-foo"`

PS: let me know if you don't like the `-add` suffix

/cc: @migueldeicaza
2018-11-06 08:05:40 -05:00
Rodrigo Kumpera ce08c32632 Merge pull request #11444 from vargaz/wasm-work10
[wasm] AOT work.
2018-11-06 07:46:18 -05:00
Bernhard Urban c200ccbb62 [mini] do not emit safepoints for methods without calls and loops (#11554)
[mini] do not emit safepoints for methods without calls and loops

with this optimization, running Roslyn with mono on
`mono/tests/pinvoke11.cs` compiles:

* 2019 methods without safepoints, and
* 9443 methods with safepoints.
2018-11-06 07:25:38 -05:00
Alexander Köplinger c8d59d1d1d [ci] Fix Windows .msi build 2018-11-06 10:40:06 +01:00
monojenkins 1b7e823963 [csproj] Update project files 2018-11-06 10:27:55 +01:00
Marek Safar 2101be92eb [corlib] Update aot testing profile to run more tests 2018-11-06 10:27:55 +01:00
monojenkins ff4496f0af [csproj] Update project files 2018-11-06 02:08:49 +00:00
Alexander Kyte 03c8728e10 [runtime] Enable usage of Runtime team sentry server (#11532) 2018-11-05 21:01:47 -05:00
Vlad Brezae efe81504bd [ci] Add jenkins script for testing fullaot + interp (#11553)
For now, run the runtime suite and a few bcl tests.
2018-11-05 16:11:08 -05:00
Vlad Brezae ef78b582a1 [corlib] Icall for Buffer.Memcpy
Jitted code is too slow. For larger sizes, doing an icall to memcpy is 4-5 times faster than using the managed implementation.
2018-11-05 21:09:55 +01:00
Vlad Brezae 0947b7b289 [corlib] Remove unused function 2018-11-05 21:09:55 +01:00
Bernhard Urban 9772a0868a [interp] transform delegate invoke in method body too (#11528)
[interp] transform delegate invoke in method body too
2018-11-05 13:15:29 -05:00
Zoltan Varga 909c8300d5 [corlib] Add stubs for timezone info for wasm, use it instead of the file system based code. 2018-11-05 01:36:29 -05:00
Zoltan Varga 994aaa7c2b [wasm] Avoid emitting gsharedvt versions of the Vector<T> simd fallback code, its large and unlikely to be used. 2018-11-04 23:48:34 -05:00
Zoltan Varga 8e1a4e2702 [jit] Implement Vector.IsHardwareAccelerated () as an intrinsics even if SIMD is not enabled to help deadce. 2018-11-04 23:47:48 -05:00
Zoltan Varga a5f51afafa [corlib] Add stubs for timezone info for wasm, use it instead of the file system based code. 2018-11-04 23:45:26 -05:00
Zoltan Varga daf92b9e62 [aot] Avoid AOTing ref instances of methods with valuetype constraints, they will never be used. 2018-11-04 18:09:34 -05:00
Alexander Köplinger 2fd171c4f9 Fix tarball build
1) We try to include every source in .sources but that doesn't work
for generic _test.sources since we'd need to prepend the Test/ path.

2) MonoNativeConfig.cs.in was removed in 273f120c52
2018-11-04 13:15:46 +01:00
Zoltan Varga ed19b6eb6f [runtime] Add a --enable-minimal=assert_messages option to remove assertion messages, only file/line numbers are retained. Enable it for wasm. 2018-11-03 23:19:46 -04:00
Zoltan Varga 0ea592b812 [wasm] Restrict the set of methods dedup-ed to a set which works. 2018-11-03 04:39:37 +01:00
Zoltan Varga 52471e886b [jit] Use mono_method_get_full_name () in a few places since it includes return types. 2018-11-03 04:39:14 +01:00
Zoltan Varga 67b3909420 [wasm] Enable dedup support. 2018-11-03 04:35:05 +01:00
Zoltan Varga ee47f34257 [wasm] Avoid linking the icall table into the app in aot mode. 2018-11-02 23:34:24 +01:00
Jonathan Chambers 02f46d3f49 Fix ref return for structs in runtime invoke wrapper. (#11514)
Use mono_mb_emit_op for CEE_LDOBJ to ensure wrapper data is added for
indirect load of a ref return value as method-to-ir expects this for wrappers.
2018-11-02 16:58:03 -04:00
Alexander Köplinger de2cb5fdde [ci] Switch to new syntax of Azure Storage plugin 2018-11-02 18:53:40 +01:00
Marek Safar a0d6531ef7 [man] Fixes --compile-all sytax (#11518) 2018-11-02 11:59:23 -04:00
Bernhard Urban 0cd8c758a8 [bcl] avoid false pinning in GCTest (#11521) 2018-11-02 10:34:28 -04:00
Bernhard Urban 9e8ff85c08 [interp] accept typed-by-ref as return type from a JIT call (#11522) 2018-11-02 10:33:06 -04:00
Jo Shields ffa8c9992f Merge pull request #11509 from directhex/cleanup-system-native-make-dist
Clean up .o files from System.Native during `make dist`
2018-11-02 10:02:53 -04:00
Marek Safar b3a2a47caf [corlib] Remove incorrectly converted silverlight check
Fixes #11478
2018-11-02 12:22:49 +01:00
monojenkins e9830a7a41 [csproj] Update project files 2018-11-02 12:19:12 +01:00
Martin Baulig 273f120c52 "Mono.Native - Halloween Edition"
In preparation of the upcoming FSW support, `Mono.Native` now supports icall registration
and has a test added for this.  This doesn't actually hook up FSW yet on iOS, but all the
preparations have been made as well as some tests for it.

* When using Bitcode (iOS only), we now link against the Mono runtime because we cannot have
  any undefined symbols.  Without Bitcode, the `mtouch` tool will do the linking for us.

* Add `-framework GSS` if needed.

* Removed `common/MonoNativeConfig.cs` - the test harness in `xamarin-macios/tests/xharness`
  now takes care of that.

* Include a few more `System.Native` files on IOS.

* `mono_native_initialize()`: New native method to initialize the module and register any
  necessary icalls.  We register a new `Mono.MonoNativePlatform::IncrementInternalCounter`
  icall for testing purposes.

* `mono_native_is_initialized()`: New native method for testing.

* `MonoNativePlatform.Initialize()`, `IsInitialized()`: Managed side of these.

* `MonoNativePlatform.IncrementInternalCounter()`: New icall, which is registered by
  `mono_native_initialize()` - this is used by the test suite to make sure the icall
  registration works.

* `NativePlatformTest`: Removed compat / unified check, see above.  Add tests to call
  the other managed APIs via reflection.
2018-11-02 12:19:12 +01:00
Jay Krell 29e3d25799 [coop] Refactor/reuse mono_value_box_handle/mono_value_box_checked and reduce raw pointers. (#11466) 2018-11-02 03:09:36 -07:00
monojenkins 3a747e10d7 Bump API snapshot submodule 2018-11-02 08:30:11 +01:00
Jb Evain c41cd66598 Make all invokable mirrors share an interface 2018-11-02 08:30:11 +01:00
Jb Evain 0e392596cf [Mono.Debugger.Soft] Refactor the InvokeMethodAsync methods to reduce duplication 2018-11-02 08:30:11 +01:00
Bernhard Urban 226a836210 [marshal] fix pointer type (#11499)
[marshal] fix pointer type
2018-11-01 18:55:35 -04:00
Dominik Przywara 81795e454e Added missing cts.Cancel() in HttpClient Dispose() method 2018-11-01 23:06:39 +01:00
Jo Shields 791ec7faea Delete more useless binary cruft from make dist 2018-11-01 14:10:24 -04:00
Jo Shields 7184737bee Clean up .o files from System.Native during make dist
Closes: https://github.com/mono/mono/issues/11501
2018-11-01 13:53:13 -04:00
Zoltan Varga 4ba22e2c78 [llvm] Fix the build. 2018-11-01 13:18:56 +01:00
monojenkins 0bd0bd3fff [bcl] Update BCL Linked Size 2018-11-01 08:47:43 +01:00
Jay Krell f57ceafa10 Reduce TLS accesses. (#11487)
* Reduce TLS accesses.
Functions with HANDLE_FUNCTION_ENTER, only call mono_thread_info_current once,
instead of 1 + per-MONO_HANDL_NEW.

This can be extended in future in multiple potential ways.
 1 Macro split from HANDLE_FUNCTION_ENTER.
   This is easiest/no downside, i.e. for functions that do not HANDLE_FUNCTION_ENTER
   but that do multiple MONO_HANDLE_NEW, call other macro
   just to mono_thread_info_current () into local.
 2 Pass TLS as seperate parameter. Probably not actually, see 4.
 3 Store TLS in handles -- too large? Probably not actually, see next.
 4 Store TLS in MonoError. i.e. MonoError is "call context", chained
   up to "thread context".
2018-10-31 20:49:29 -07:00
Aleksey Kliger (λgeek) d28db369f1 Implement MONO_ENTER_NO_SAFEPOINTS/MONO_EXIT_NO_SAFEPOINTS (#11476)
* [threads] Add a no_safepoints bit to the thread state machine.

Only valid on RUNNING or ASYNC_SUSPEND_REQUESTED.
Currently no transitions set the bit, but the expectation is that it can only
be set/unset by the current thread on itself and only in RUNNING or
ASYNC_SUSPEND_REQUESTED.
Transitions to suspended states or to GC Safe states are forbidden if
wont_safept is set.

The intention is that this is used by a thread to mark a scope where it will
not safepoint (perhaps because it wants to manipulate a raw ptr to a managed
object).

The wont_safept bit only makes sense for cooperative suspension.  For async, we
have the critical regions (which should be much more rarely needed).

* [threads] Add state machine funcs to query/set/uniset wont_safept

* [threads] add MONO_ENTER_NO_SAFEPOINTS/MONO_EXIT_NO_SAFEPOINTS macros

A region between MONO_ENTER_NO_SAFEPOINTS/MONO_EXIT_NO_SAFEPOINTS must not call
any function that could: reach a safepoint (and suspend the current thread),
allocate memory from the managed heap, or transition to GC Safe.  In such a
region it is safe to dereference a pointer to managed memory and use read/write
from it (an alternative to avoid the no safepoints region is to pin the memory
with a global GC handle before manipulating it).  GC Write barriers still need
to be used.

The current design doesn't allow nesting - the underlying thread state
transitions check that the flag isn't already set - keep the regions short and simple.

* [sgen] Don't initiate STW from a thread in a NO_SAFEPOINTS region

In other words, if you were in
MONO_ENTER_NO_SAFEPOINTS/MONO_EXIT_NO_SAFEPOINTS, you shouldn't be calling
anything that would start the GC
2018-10-31 23:39:20 -04:00
Zoltan Varga 761398d080 [aot] Add some comments. 2018-11-01 03:02:13 +01:00
Alexander Köplinger 75f3c0cc0c [System.Drawing] Fix test build for wasm profile
It was recently switched to only contain the netstandard20 subset of types.
2018-11-01 02:04:40 +01:00
Bernhard Urban e1c6c78158 [ci babysitter] Add more output around timeout killing machinery (#11463) 2018-11-01 00:42:37 +01:00
Bernhard Urban e67699917c [runtime] allocate volatile_{locals,args} bitset in image mempool (#11490)
Fixes https://github.com/mono/mono/issues/11488, an regression introduced by https://github.com/mono/mono/pull/11294
2018-11-01 00:40:49 +01:00
Marek Safar af2c781c2e [corlib] Tweaks few linker descriptors to be more precise 2018-10-31 20:49:02 +01:00
Zoltan Varga 9960c5b419 [llvmonly] Rework the handling of direct calls.
Move the allocation of got offsets for calls to a separate pass after all methods have been compiled. This means
that got offsets do not need to be allocated for calls which can be turned into direct calls.
2018-10-31 19:55:59 +01:00
Alexander Köplinger c36045510c Bump nunitlite to get WASM-related fix 2018-10-31 17:34:33 +01:00
Michael Voorhees 8ca2e209aa Additional constructor preservations
Upcoming changes to monolinker will make additional optimizations when no instance ctors are marked.

To be safe, add preservations for the ctor's of types that are created in the runtime.

The change to preserve the .ctor() of`System.Runtime.Remoting.Messaging.AsyncResult`  was made for more than out of caution.  We have a simple delegate test that hung without this.
2018-10-31 15:31:21 +01:00
Alexander Köplinger 4b1e93d2ee Bump corefx to get disabled test 2018-10-31 14:31:51 +01:00
Marek Safar 22995f84af Bump corefx (#11482)
* Bump corefx

* Bump API snapshot submodule
2018-10-31 14:08:19 +01:00
monojenkins 6ef9162b78 [csproj] Update project files 2018-10-31 14:08:04 +01:00
Marek Safar 103999d3cd [corlib] Tweak more wasm defines 2018-10-31 14:08:04 +01:00
Alan Grgic 7a23177292 Add missing constructor in System.Security.Policy.Evidence (#11480)
Fixes #7750.
2018-10-31 13:54:21 +01:00
Marek Safar 5493154046 [corlib] Remove tests which were moved to System.Core 2018-10-31 13:47:08 +01:00
majellin24 92711632bf Modification to allow deserialization of derrived types (#11194)
* Modification to allow deserialization of derrived types

* white space correction

* second attempt

* third attempt

* fourth

* whitespace

* maybe fix null ref exception

* missed same condition in other method

* fixing condition

* hopefully correcting the test failure in AOT

* Modification to allow deserialization of derrived types

white space correction

second attempt

third attempt

fourth

whitespace

maybe fix null ref exception

missed same condition in other method

fixing condition

hopefully correcting the test failure in AOT

formatting

missed some formatting

* adding a test for PR #11194

* fixing a few exceptions

* adding ref
2018-10-31 10:43:46 +01:00
Bernhard Urban aa37f45a3d [tests] reduce recursion depth
so it doesn't trigger a stack overflow on Xamarin.iOS with interpreter on a debug build (`CFLAGS=-O0`).
2018-10-31 10:36:15 +01:00
monojenkins 7ac56e5794 [csproj] Update project files 2018-10-31 10:10:16 +01:00
monojenkins 1ab2271e74 Bump API snapshot submodule 2018-10-31 10:10:16 +01:00
Maxim Lipnin c671d31c41 Move TODO comment regarding GetBaseMethod from reference source to MonoMethod class 2018-10-31 10:10:16 +01:00
Maxim Lipnin 11ea7fdd7f [Reflection] CoreFX import for MethodInfo type 2018-10-31 10:10:16 +01:00
Alexander Kyte dd9e11fba8 [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:21:21 +01:00
Alexander Köplinger 7645c8b8f0 Revert "[interp] Optimise method execution start (#11328)"
This reverts commit ecf399da07.

It breaks a webassembly test.
2018-10-31 01:35:06 +01:00
Zoltan Varga db5666c72c [jit] Fix the s390x build. (#11474) 2018-10-31 01:28:56 +01:00
Vlad Brezae 5204ef1f5c [tests] Add new build profile for testing mixed mode (#11307)
We aot only the bcl (--aot=full,interp) while the tests code is interpreted.

<!--
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-30 15:48:46 -04:00
Alexander Köplinger 555e5c5214 [mini] Fix missing semicolon in mini-s390x.c
Typo from 38caaf67b1
2018-10-30 20:38:30 +01:00
Alexander Kyte 58d5e154b7 [crash] Fix merp invocation (#11435)
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:24:38 +01:00
Marek Safar 263e59de65 [System.Core] Adds ~28k corefx tests (#11445) 2018-10-30 18:27:33 +01:00
Marek Safar a84d2bcdef [corlib] Deletes unused code 2018-10-30 17:43:22 +01:00
Vlad Brezae ecf399da07 [interp] Optimise method execution start (#11328)
[interp] Optimise method execution start

This can lead to 4% general speedup

<!--
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-30 11:35:44 -04:00
Nikolay Sivov d3af6d44ff [metadata] Compiler warnings fixes. (#10893)
* [metadata] Fix strict prototype warning.

* [metadata] Remove unused variable.

* [metadata] Fix unused function warning.

* [metadata] Fix unused function warning for swap_with_size().

* [metadata] Fix "may be uninitialized" warnings.

* [metadata] Simplify missing ICustomMarshaler exception throwing case.

With current code there is no reason to have explicit jump label.
2018-10-30 10:14:54 -05:00
Bernhard Urban 36c27a2328 [interp] fix definition of MINT_CKNULL_N (#11447)
So that the debug output renders the operand of `MINT_CKNULL_N`
correctly.
2018-10-30 11:11:50 -04:00
Bernhard Urban 8e0cbf1044 [gitgnore] put .dylib on ignore list (#11453) 2018-10-30 09:41:45 -04:00
Ankit Jain f038e7cd8a Bump msbuild to track xplat-master (#11440)
- pickup fix for https://github.com/mono/mono/issues/11214 .
2018-10-30 13:28:53 +01:00
Bernhard Urban adc72216b3 [delegates] do not use CEE_CALLVIRT for non-virtual methods (#11433)
[delegates] do not use CEE_CALLVIRT for non-virtual methods
2018-10-30 06:05:33 -04:00
Martin Baulig 40ac474150 [System]: lock protect SystemCertificateProvider.EnsureInitialized(). 2018-10-30 10:33:47 +01:00
Jay Krell 2be23d7835 One version of ves_icall_...StringToHGlobalUni is better than two. (#11404) 2018-10-29 23:16:50 -07:00
Zoltan Varga 7ef033cf8d [aot] Remove unused got_offset arguments from a few functions. Fix a warning. NFC. 2018-10-30 04:29:25 +01:00
Jay Krell 8f26798fee Disable failing assert in failing test DebuggerTests.Threads Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState) (#11419)
Disable failing assert in failing test DebuggerTests.Threads Assert.AreEqual (ThreadState.Stopped, e.Thread.ThreadState)

https://github.com/mono/mono/issues/11416
2018-10-29 18:35:31 -04:00
Vlad Brezae 4ab5d5398f [interp] Init also vtstack value types when allocated (#11425) 2018-10-29 22:37:52 +02:00
Zoltan Varga c0da2a5126 [wasm] Bitcode code generation improvements (#11413)
* [llvm] Rewrite the bitcode get_method () generated method to load the result from a table on wasm instead of a huge
switch statement.

This might be usable on other platforms in the future but having a table full of function pointers might lead to linking
problems.

* [llvm] Make direct calls to jit icalls without wrappers as well.

* [llvm] Export mono_llvm_clear_exception () with G_EXTERN_C, its called from llvm generated code.

* [wasm] Emit target layout/target triple into bitcode files.

* [aot] Allow the decoding of references to icall wrappers, so compiled code can reference them directly using a MONO_PATCH_INFO_METHOD.

* [llvm] Call icall wrappers directly from corlib code in llvmonly mode instead of going through the GOT.

* [llvm] Instance methods without got accesses don't need initialization in llvmonly mode.
2018-10-29 20:06:01 +01:00
Jay Krell 985be3e594 [Coop] Convert ves_icall_System_Environment_InternalSetEnvironmentVariable. (#11408) 2018-10-29 08:46:47 -07:00
monojenkins 251409f040 [csproj] Update project files 2018-10-29 16:03:44 +01:00
monojenkins cda073e850 Bump API snapshot submodule 2018-10-29 16:03:44 +01:00
Marek Safar 11baeccd48 [Facades] Adds NS21 APIs 2018-10-29 16:03:44 +01:00
Robin Sue f72e959c8c [wasm] Extend WasmHttpMessageHandler (#11255)
- Adds support for HttpCompletionOption.ResponseHeadersRead by delaying reading of the response body into HttpContent
- Adds optional support for streaming responses in supported browsers
- Adds support for canceling in flight fetch requests
2018-10-29 11:31:34 +01:00
Kenneth Pouncey ca9f1b0cb7 [wasm] Wasm sample docs (#11347)
Create docs directory and update sample documentation.

- Add getting started docs directory
- Add section of obtaining the mono distribution.

resolves: https://github.com/mono/mono/issues/11346

Fix distribution package from wasm build to have the same structure as `packager.exe` is expecting.

resolves: https://github.com/mono/mono/issues/11344
2018-10-29 11:29:44 +01:00
Johan Lorensson 1ec7ac5438 Add option to integrate msvc build into regular make build. (#11343)
* Integrate msvc build into make build system.

Add support to perform msvc build as part of regular make build. By default
msvc build will not automatically be done and needs to be enabled using
--with-msvc argument passed to ./autogen.sh. Doing msvc build as part of
regular make will automatically set MONO_EXECUTABLE to build msvc build
Mono runtime used in BCL and Test build as well as runtime used when running
tests.

* Add support to install msvc build mono runtime.

* Disable --with-msvc argument for none Windows builds.

* Fix VS2015 Build Tools build environment.

* Updated with review feedback switching to --enable-msvc.
2018-10-28 18:18:28 -04:00
Jay Krell 668933de7f Remove dead mono_signature_get_managed_fmt_string prototype. (#11409) 2018-10-28 18:07:46 -04:00
Jay Krell 7b5cac0539 [w32file] Restrict mono_w32file_get_volume_information interface to its actual implementation and usage.
On all platforms, mono_w32file_get_volume_information is only asked for its last parameter.
So replace mono_w32file_get_volume_information with mono_w32file_get_file_system_type that
only takes that parameter.
2018-10-28 18:07:13 -04:00
Alexander Köplinger a682a3b2b6 Fix tarball build
Forgot to add a file to EXTRA_DIST
2018-10-28 01:22:07 +02:00
Marek Safar ea967a0718 [runtime] Fixes threadpool tests not to rely on arbitrary sleep timeout (#11348) 2018-10-27 23:42:10 +02:00
Jay Krell 31473ac156 Update some comments. (#11382) 2018-10-27 16:58:12 -04:00
Jay Krell c299a99431 Disable flaky tests finalizer-abort.exe, process-stress-2.exe, process-stress-3.exe. (#11418) 2018-10-27 16:49:52 -04:00
Aleksey Kliger (λgeek) ab51a8172e [reflection] Implement RuntimeType.IsByRefLike (#11111)
* [reflection] Implement RuntimeType.IsByRefLike

* [runtime] Add MonoClass:is_byreflike bit

Not set anywhere yet.

* [custom_attrs] Add mono_class_metadata_foreach_custom_attr

Unlike mono_custom_attrs_from_class_checked, this iterator function iterates
over the metadata without taking the loader lock or constructing class
instances, so it is safe to use during assembly loading or class initialization.

* [class-init] Set is_byreflike from attributes in mono_class_create_from_typedef

* [class-init] Set is_byreflike for generic instances

* [class-init] fail arrays of IsByRefLike elements

* [class-init] Check for ByRefLike struct fields

ByRefLike types only allowed as instance fields of structs that are
themselves ByRefLike.

* [runtime] Disallow instantiating generics with ByRefLike types

Instantiating a generic with a `ref struct` is not allowed.

* [runtime] Disallow instantiating generics with TypedReference

Reverts f457a01416. That was a hack to support
gsharedvt (gsharedvt worked by hijacking TypedReference to instantiate generic
vars since it's a lightly used class) that we no longer rely on (we now
instantiate generic vars by types that are synthesized for purpose).

* [mini] Don't box IsByRefLike types

* [runtime] Disallow boxing IsByRefLike types

* Bump corlib version

* [tests] Test that JIT won't box or instantiate IsByRefLike types

* [metadata] Don't inflate methods with invalid generic arguments

* [metadata] Make mono_is_valid_generic_argument non-static

Make it callable from other translation units.

* [class-init] Check for invalid generic instantiations

Disallow instantiations that contain void, TypedReference or IsByRefLike structs.

* [interp] Don't box IsByRefLike structs
2018-10-27 11:03:42 -05:00
Jay Krell 12b2b48504 [icalls] Dial back a few functions from HANDLES to NOHANDLES, (#11386)
* [icalls] Dial back a few functions from HANDLES to NOHANDLES,
that take/return no objects, nor have error paths.
2018-10-27 07:48:57 -07:00
Jay Krell e75c972ef8 [Coop] Convert mono_custom_attrs_from_builders. (#11394) 2018-10-27 07:03:35 -07:00
Zoltan Varga ec1c08afa5 [llvm] Fix passing vtypes received by value as arguments, they need to be copied. Fixes https://github.com/mono/mono/issues/11378. (#11389) 2018-10-27 12:42:46 +02:00
Marek Safar 9214bdc7be [corlib] Replace few more simple types with corefx (#11401) 2018-10-27 01:46:20 +02:00
Alexander Köplinger 73afc0361a [profiler] Add xunit xml profiler tests output and allow tests to run from outside the build tree (#11383)
We need xunit xml output for Helix.

The new mode which doesn't rely on build tree paths can be enabled by passing the special value "out-of-tree" as the build dir.

Respects the MONO_EXECUTABLE env variable and bases everything off of that.

Also unified run_test and run_test_sgen since we only have sgen nowadays and we only need one.
2018-10-27 00:32:58 +02:00
Bernhard Urban f8f574ded5 [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-26 17:45:32 -04:00
Aleksey Kliger (λgeek) e522b00d40 [marshal] Delete unused locals in emit_managed_wrapper_ilgen (#11379)
[marshal] Delete unused locals in emit_managed_wrapper_ilgen

`ex_local` and `e_local` were used prior to
https://github.com/mono/mono/commit/b20d5ce1e5d69512242dd42ae6ff1afc2483c16d
in order to store an exception raised by the managed method before passing it
to `ftnptr_eh_callback`.  After that commit, we invoke the callback from the
stack unwinder, rather than from the method wrapper.  As a result both of the
locals are now dead code.
2018-10-26 16:35:26 -04:00
Alexander Köplinger d34dfd46d0 [profiler] Reenable tests when using hybrid suspend (#11402)
They got disabled with https://github.com/mono/mono/commit/282ee4bfd7ea91dc0015891010c71d8bd1421bc8 but now that hybrid suspend is the default on multiple platforms we should reenable them.
2018-10-26 22:23:45 +02:00
Marek Safar 16db2720aa [runtime] Disables crashing appdomain-threadpool-unload.exe test (#11393) 2018-10-26 11:45:55 -04:00
Henric Müller ee661a08db Add .NET 4.7.2 reference assemblies (#11391)
Adding .NET 4.7.2 reference assemblies by updating submodule reference and adding new framework to mcs/tools/xbuild/frameworks and update Makefile to ship as described in #8657.
2018-10-26 15:41:40 +02:00
Bernhard Urban 9292e8a605 [interp] enable more BCL tests (#11381)
[interp] enable more BCL tests

probably won't pass on all configurations, I wanna find out on which.
2018-10-26 09:05:39 -04:00
Katelyn Gadd 786f58bf83 Partially exclude custom modifiers from metadata type equality (#11134)
Fixes #10945
Reverts fix for #6936

https://github.com/mono/mono/issues/10945 appears to have been introduced by https://github.com/mono/mono/commit/9dc6c344ac34a470fa0f4fc411e357f7eaf577fd. Unfortunately it is not possible to revert the commit at this point using git revert, but manually disabling the equality change fixes BinaryFormatter. This should be sufficient to get a lot of the broken roslyn tests working again.
2018-10-26 12:35:12 +02:00
Jay Krell 5b8b0f20ac [Coop/icalls] Convert a few, nohandles() a few, cleanup a few. (#11355)
* [Coop] Convert ves_icall_System_Object_MemberwiseClone.
[Coop] Convert ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue.
[Coop] Convert ves_icall_MonoField_get_core_clr_security_level.
[Coop] Convert ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor.
[Coop] Convert ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor.
[coop] Remove redundant declarations.
[Coop] Nohandles ves_icall_System_Environment_Exit.
[Coop] Nohandles ves_icall_System_Environment_GetIs64BitOperatingSystem.
[Coop] Nohandles mono_pagesize.
[Coop] Nohandles mono_environment_exitcode_get.
[Coop] Nohandles ves_icall_System_Environment_get_HasShutdownStarted.
[Coop] Nohandles ves_icall_System_Environment_get_Platform.
[Coop] Nohandles ves_icall_System_Environment_get_ProcessorCount.
[Coop] Nohandles ves_icall_System_Environment_get_TickCount.
[Coop] Nohandles mono_environment_exitcode_set.
[Coop] Nohandles ves_icall_System_Reflection_AssemblyName_GetNativeName.
[Coop] Nohandles ves_icall_System_Reflection_AssemblyName_ParseAssemblyName.
[Coop] Nohandles mono_digest_get_public_token.
[Coop] Nohandles ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData.
[icalls] Cleanup ves_icall_System_Environment_get_HasShutdownStarted.
[icalls] Cleanup ves_icall_System_Environment_BroadcastSettingChange.
[icalls] Cleanup ves_icall_IsTransparentProxy.
[icalls] Cleanup ves_icall_Remoting_RemotingServices_GetVirtualMethod.
[icalls] Cleanup ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation.
[icalls] Cleanup ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance.
[icalls] Cleanup ves_icall_RuntimeMethodHandle_GetFunctionPointer.
[icalls] Cleanup ves_icall_System_Configuration_DefaultConfig_get_machine_config_path.
[icalls] Cleanup ves_icall_System_Configuration_InternalConfigurationHost_get_bundled_app_config.
[icalls] Cleanup ves_icall_System_Web_Util_ICalls_get_machine_install_dir.
[icalls] Cleanup ves_icall_get_resources_ptr
[icalls] Cleanup ves_icall_System_Diagnostics_Debugger_IsLogging.
[icalls] Cleanup ves_icall_System_Activator_CreateInstanceInternal.
[icalls] Cleanup ves_icall_MonoMethod_get_base_method.
[icalls] Cleanup ves_icall_MonoMethod_get_name.

* Replace mono_error_ok with is_ok.
* Remove outdated comment.
* Use return_if_nok where applicable.
* Use return_val_if_nok where applicable.
* Use NULL_HANDLE_ARRAY where applicable.
2018-10-26 01:41:32 -07:00
Alexander Köplinger cc6157a1c1 [Mono.Profiler.Log] Use full path for temporary .mlpd's (#11384)
So they don't depend on the working dir.
2018-10-26 04:29:51 +02:00
Alexander Köplinger a509e43cc1 [Mono.Debugger.Soft] Disable flaky Crash() test 2018-10-26 00:32:22 +02:00
Zoltan Varga c1e21d488a [wasm] WASM work. (#11314)
* [wasm] Handle the /dev/random problems by defining 'crypto' in runtime-tests.js instead of in the runtime/library_mono.js.
Print a	stack trace if runtime_invoke () throws	a JS exception.

* [wasm] Add a mono_wasm_setenv () function to the MONO module.

* [wasm] Mark some corlib tests as MultiThreaded/NotWasm.
2018-10-25 17:40:38 -04:00
Jay Krell 8fba63a2a3 [cxx] Fix WebAssembly/C++ (ICALL_EXPORT) (#11359)
Remove ICALL_EXPORT on all implementations.
Add ICALL_EXPORT on two declarations.

ICALL_EXPORT is on declarations, correctly,
  and either isn't needed on implementations, or is incorrect.
On non-handles() implementations, it isn't needed but is ok.
On handles() implementations, it is incorrect.

Add ICALL_EXPORT on mono_object_hash_internal and mono_monitor_exit_internal.

Previously many declarations were missing, which was a reason we put it on implementations.
2018-10-25 13:07:05 -07:00
Alexander Köplinger bf12b8762d [build] Enable netstandard facade in the "build" profile (#11377)
* [build] Enable netstandard facade in the "build" profile

It is necessary for a helix tool which I'm building in this profile
and it relies on NS2.0.

Adding full NS2.0 would require building System.Transactions.dll,
System.Runtime.Serialization.dll and System.Data.dll too but those
in turn rely on a whole bunch of other junk that I don't want to bring
into the build profile. Therefore I just added stubs for the types
directly into netstandard.dll.

* [csproj] Update project files
2018-10-25 21:38:10 +02:00
Neale Ferguson 8e44a7fa0c A couple of missing mono_class_from_mono_type_internal changes (#11372)
A couple of missing mono_class_from_mono_type_internal changes

Two instances were missed when mono_class_from_mono_type was changed to mono_class_from_mono_type_internal
2018-10-25 14:35:33 -04:00
monojenkins 5cf1cb8a4e [csproj] Update project files 2018-10-25 20:11:08 +02:00
monojenkins c40bbf93b0 Bump API snapshot submodule 2018-10-25 20:11:08 +02:00
Marek Safar 7ebb2f989d [corlib] Adds back accidentally removed legacy COM API to Binder 2018-10-25 20:11:08 +02:00
Alexander Köplinger 87493e96fb [System.Runtime.Serialization] Fix possible race when creating the test response file
test_lib might not be set yet at this point since we're including library.make
later on, use LIBRARY instead which is set further above.
2018-10-25 18:56:00 +02:00
Alexander Köplinger c91486cc2d Fix tarball build by including upload-to-sentry 2018-10-25 15:20:15 +02:00
Marek Safar 7ec5a9af87 [build] Fixes wasm tools to run on desktop .net as well (#11351)
* [build] Fixes wasm tools to run on desktop .net as well

Fixes #11326

* [csproj] Update project files
2018-10-25 15:13:46 +02:00
Bernhard Urban cb467ff359 [interp] fix unused variable warnings (#11365)
```
interp/interp.c:2337:17: warning: unused variable 'entry_funcs_static' [-Wunused-variable]
static gpointer entry_funcs_static [MAX_INTERP_ENTRY_ARGS + 1] = { INTERP_ENTRY_FUNCLIST (static) };
                ^

interp/interp.c:2338:17: warning: unused variable 'entry_funcs_static_ret' [-Wunused-variable]
static gpointer entry_funcs_static_ret [MAX_INTERP_ENTRY_ARGS + 1] = { INTERP_ENTRY_FUNCLIST (static_ret) };
                ^

interp/interp.c:2339:17: warning: unused variable 'entry_funcs_instance' [-Wunused-variable]
static gpointer entry_funcs_instance [MAX_INTERP_ENTRY_ARGS + 1] = { INTERP_ENTRY_FUNCLIST (instance) };
                ^

interp/interp.c:2340:17: warning: unused variable 'entry_funcs_instance_ret' [-Wunused-variable]
static gpointer entry_funcs_instance_ret [MAX_INTERP_ENTRY_ARGS + 1] = { INTERP_ENTRY_FUNCLIST (instance_ret) };
                ^

4 warnings generated.
```
2018-10-25 15:07:45 +02:00
Martin Baulig a52744eeeb [System.Core]: Stub out Interop.Sys.GetEUid and SetEUid. (#11366)
* [System.Core]: Stub out `Interop.Sys.GetEUid` and `SetEUid`.

This is a temporary fix; the native side still needs to be ported from c++
and tested.

* [csproj] Update project files
2018-10-25 15:06:22 +02:00
Alexander Köplinger 6532ffee6b Bump boringssl submodule to get PPC32 fix 2018-10-25 13:48:13 +02:00
monojenkins d0069a948d [bcl] Update BCL Linked Size (#11361) 2018-10-25 03:34:04 +02:00
Alexander Köplinger 741a5d954a Revert "Fix const warning. And integer overflow for degenerate input. And C++. (#11088)"
This reverts commit dc43c6b469.

It causes regressions on WASM: https://jenkins.mono-project.com/job/test-mono-mainline-wasm/label=ubuntu-1804-amd64/1297/
2018-10-25 03:27:20 +02:00
Jay Krell 0c229900fe Remove errant character from 3bf5c2bd10 that breaks compile. (#11360) 2018-10-25 02:38:00 +02:00
Jay Krell dc43c6b469 Fix const warning. And integer overflow for degenerate input. And C++. (#11088)
https://jenkins.mono-project.com/job/test-mono-pull-request-wasm-cxx/536/parsed_console/log.html

driver.c:254:11: warning: passing 'const char *' to parameter of type 'char *' discards qualifiers [-Wincompatible-pointer-types-discards-qualifiers]
                strcpy (&name [len - 3], "dll");
                        ^~~~~~~~~~~~~~~
/mnt/jenkins/workspace/test-mono-pull-request-wasm-cxx/sdks/builds/toolchains/emsdk/emscripten/1.38.11/system/include/libc/string.h:31:31: note: passing argument to parameter here
char *strcpy (char *__restrict, const char *__restrict);
2018-10-25 01:36:58 +02:00
Bernhard Urban 3bf5c2bd10 [aot] add unbox_arbitrary_trampoline for fullaot/interp mixed mode (#11321)
* [aot] add unbox_arbitrary_trampoline for fullaot/interp mixed mode

On a virtual call where the receiver is a value type, the value type is
boxed at the caller's site, but must be unboxed before passed to the
callee. In FullAOT this happens with the help of the `unbox_trampoline`,
which is attached to the AOT'd assembly for every virtual method with a
value type as receiver, so we have a specific `unbox_trampoline` for
each such `MonoMethod`.

In mixed mode it can happen that an FullAOT'd method is calling such a
method which is _not_ FullAOT compiled, therefore it has to be executed
by the interpreter. We have to insert a trampoline between AOT caller
and interp callee (being a native-to-interp entry), that does the
unboxing and has a configurable target address at run-time. So that:

  AOT caller -> unbox_arbitrary_trampoline -> native-to-interp entry

Note on testing: Tested on three different configurations
* amd64/macos with --full-aot-interp and `make -C mcs/class/corlib TESTNAME=MonoTests.System.ArrayTest.BinarySearch_ArgPassingOrder`. This will be covered soon by https://github.com/mono/mono/pull/11307.
* arm64/linux, same as above.
* arm64/iOS which has a different code path due to trampoline pages being used. Tested with `monotouch-tests` mixed mode (i.e. mscorlib.dll FullAOT, rest is interpreter).

armv7 isn't implemented yet.

* fix llvm aot compiler

* unbox_arbitrary_trampoline support for ARM
2018-10-25 01:20:12 +02:00
Jay Krell 1ac2c5218e Remove GetOffsetToStringData (but leave ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData, it is used). (#11353) 2018-10-25 01:15:50 +02:00
Marek Safar 8023c9822c [build] Add more tools for monodroid to reduce sources dependency (#11352)
* [build] Add more tools for monodroid to reduce sources dependency

* [csproj] Update project files
2018-10-25 01:09:52 +02:00
Egor Bogatov 207b9b03df Fix bcl-size-diff calculation (#11357)
The BCL size regression (see https://github.com/mono/mono/pull/11041) was actually caused by changes in linker/Makefile: https://github.com/mono/mono/commit/539b14892000f3c4b13657161819680dd9aa098c#diff-f2d312cb75589935c2b11af219414f48L73
With this fix it's green again:

![image](https://user-images.githubusercontent.com/523221/47464597-5f8e0300-d7f2-11e8-88ac-b3e6e6129c81.png)
2018-10-25 01:03:50 +02:00
Rolf Bjarne Kvinge d86fdaf3ab [System.Net.Http] Comment out dead code. (#11331)
Comment out code to convert NSUrlError to WebExceptionStatus, because the
result isn't used. Looking through git history it seems the resulting
WebExceptionStatus was never used.

Fixes this warning:

    HttpClientEx.cs(83,8): warning CS0219: The variable 'webExceptionStatus' is assigned but its value is never used
2018-10-25 00:26:34 +02:00
Marek Habersack 0d68ffd1ce [SDKS, LLVM] Disable detection and use of libxml2 (#11340)
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:22:37 +02:00
Aleksey Kliger (λgeek) 0c8fbcd970 [tests] Regression test for #11123 (#11312)
Loading a type that has a field from an assembly that cannot be loaded should
still leave the type usable for some operations such as IsSubclassOf.
2018-10-25 00:21:24 +02:00
Rodrigo Kumpera 3039d6f3f0 [wasm] Improve build reliability. (#11349)
* [wasm] Fix wasm toolchain bootstraping

* [wasm] Move the provision step to happen before the build.
2018-10-25 00:20:35 +02:00
Alexander Köplinger cd47933265 Bump corefx 2018-10-25 00:14:49 +02:00
Jay Krell e8b0376421 Stack-based icall parameter handles and only one managed/native transition per icall. (#11294)
Handles for icall parameters allocated in managed (but not native), can just be pointers to locals or parameters.

Currently the managed stack is scanned conservatively.
When this changes, there will be metadata provided to find these, so this approach will just keep working and should still be ideal (aside from nohandles or staying in managed).

For ObjIn, use pointer to parameter.
For ObjOut/ObjInOut, the parameter might, though it is far fetched, point to a native frame, which isn't convincing. Therefore for those, use a pointer to a managed volatile local, closer to how handles looked like.
For ValueTypeRef, make the parameter volatile so it is sure to survive.

We use volatile instead of merely address-taken because 1. a hypothetical aggressive whole program compiler/optimizer could see through address-taken (runtime and wrappers and corlib compiled together).  2. ValuetypeRef is even easier to optimize/break because the address-taken is  dead.

FIXME: Tests that exercise every icall, coop and otherwise.
FIXME: Gcstress.

Collateral damage: The one rarely run assert that handles are not out of scope
cannot be so easily implemented so is removed. It might come back though, if we type tag the handles.

Furthermore, the handle stack setup/cleanup can be done in native instead of managed.
Furthermore, the error check can either be done in native instead of managed, or the fast path inlined in the JIT. Here we just move it to native (and inline the fast path in native).

Therefore coop icalls go from 3 + handle-count managed/native transitions, to just always one,  *and* at least some of their handle allocation is exceedingly fast and free of TLS.

The typed handle wrappers change from returning a handle to returning a raw pointer.
Because previously the handle would be allocated in the handle frame setup by the JIT.
Now the JIT doesn't setup a handle frame.

There is a weakreference test that is seemingly very sensitive to stack layout.
For this reason at least, the MonoError is still allocated on the managed side.
 Moving it to native broke the test.
This might also be preferable for the public interface.

Coop icalls retain some costs:
  - The volatile might cost a little -- lack of enregistration.
  - Native code allocating handles.
  - Still TLS access.
  - JIT icalls (vs. metadata-driven) still native-only handle allocation, and still fully manual conversion.
  - Coop icalls that return an object always allocate a handle -- could be more efficient out or inout handle instead, though inout is currently very rare.

Some of this can be further mitigated.
Mainly, the metadata icall signatures could move the "local" handles  to be out parameters, in order for managed to allocate them.

The JIT icalls could have richer signatures than just "ptr" and gain these wrappers, or previous (ref parameters, retyped as handles).
2018-10-24 09:38:19 -07:00
Zoltan Varga 38caaf67b1 [jit] Remove unused mono_arch_instrument_prolog ()/epilog () functions. (#11304) 2018-10-24 12:18:47 -04:00
Maxim Lipnin f933418246 Fix the issue when ParameterInfo.RawDefaultValue returns Missing.Value for non-null default values of DateTime?` and decimal? parameters (#11330) 2018-10-24 14:33:38 +02:00
Marek Safar 45a2ea63ce [corlib] Remove unused files (#11322)
* [corlib] Remove unused files

* [csproj] Update project files
2018-10-24 14:17:23 +02:00
Alexis Christoforides 05bc22015c [corlib] Import System.IO.TextReader/StreamReader from CoreFX (#11044)
* [corlib] Import System.IO.TextReader/StreamReader from CoreFX

* Bump API snapshot submodule

* [csproj] Update project files
2018-10-24 04:16:01 -04:00
Aleksey Kliger (λgeek) 1680235bda [wasm] Add missing include (#11335)
Fixup for
https://github.com/mono/mono/commit/5e961c6deb27c6bfc46cdba99274bbe02f8f0562
2018-10-23 22:28:55 +02:00
Maxim Lipnin 5392af120b [Reflection] Fix ParameterInfo's custom modifiers order (#11308)
* [Reflection] Reverse custom modifiers order in ParameterInfo's  GetRequiredCustomModifiers and GetOptionalCustomModifiers methods to follow NetFX/CoreFX behavior.

* Move reversing custom modifiers from managed code to native one.

* Small refactoring

* Disable System.Reflection.Emit related test on Full AOT mode.
2018-10-23 19:08:48 +02:00
Aleksey Kliger (λgeek) 5e961c6deb [marshal] Emit GC Safe transitions around foreign internal calls. (#11183)
* [threads] Make mono_add_internal_call external only

The runtime should use mono_add_internal_call_internal or
mono_add_internal_call_with_flags.

The thread suspend mechanism needs to know if an icall is added via the legacy
mono_add_internal_call API (which is not coop-aware, and so the registered
icalls must run in GC Safe mode), or if it is added by the runtime or by a
cooperative client (currently either the profiler or the System.Native PAL)
which knows to add GC transitions and safepoints and not to block indefinitely.

* [marshal] Factor out GCSafeTransitionBuilder

Make a local builder for creating the GC Safe transition calls for a method wraper.

* [sgen] Add coop GC transitions in mono_gc_toggleref_add

Also mark it external only. It's not used inside the runtime.

* [marshal] Emit GC Safe transitions around foreign icalls.

A foreign icall is added using mono_add_internal_call and that is not coop GC
aware.  (The runtime uses mono_add_internal_call_with_flags or
mono_add_internal_call_internal)

Under hybrid suspend, foreign icalls will run in GC Safe mode and transition to
GC Unsafe only when the call back into the runtime or invoke managed code.

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

* [cxx] function type overloads for mono_add_internal_call_internal

and mono_add_internal_call_with_flags

* [runtime] Add new API call mono_dangerous_add_raw_internal_call

Under hybrid suspend, this adds an icall that is assumed to run in GC Unsafe
mode.  As such it has additional requirements for correct operation: it must
not run loops without periodically polling the runtime, and it must not perform
blocking operations such as blocking I/O or taking locks without manually
switching to GC Safe mode.
2018-10-23 11:42:45 -05:00
Miguel de Icaza 8a1377130f [wasm] Add bindings API documentation 2018-10-23 11:28:55 -04:00
Egor Bogatov 4693c9775c [corlib] DateTime, TimeSpan and TimeZone from CoreFX (#11232)
* DateTime from corefx

* TimeZone and TimeSpan from corefx

* bump corefx

* remove some reflection tests temporarily (due to corefx bump)

* ignore "Obsolete" warrning-error in System.XML (because of TimeZone)

* undo submodules

* remove TimeZone.cs

* Add tests

* clean up

* fix failing TZ tests

* Add HebrewCalendar as optional to "he" culture

* ignore failing tests

* Bump API snapshot submodule

* [csproj] Update project files
2018-10-23 17:25:30 +02:00
Alexander Kyte 109563930d [crash] Add mono_crash uploader for Sentry (#10840)
* [crash] Report which thread was crashing

* [crash] Added upload-to-sentry tool

* [crash] Add sentry uploader step to telemetry
2018-10-23 17:24:26 +02:00
Maxim Lipnin 5de2976c11 Enable more corefx reflection tests (#11221)
Part of #9660 

Instead of https://github.com/mono/mono/pull/11025

https://github.com/mono/corefx/pull/152 needs to be merged.
2018-10-23 14:06:58 +02:00
Jay Krell c1e5e1d395 Remove two accidentally added functions from old version of a commited PR. (#11289) 2018-10-22 15:29:48 -07:00
Jay Krell 3c74df5667 [coop] Transition all functions in object.h to MONO_RT_EXTERNAL_ONLY (#11188)
In general this is achieved by renaming mono_foo to mono_foo_internal,
and mono_foo_bar calls mono_foo_bar_internal, possibly adding a GC mode change
to mono_foo_bar and removing from mono_foo_bar_internal.

We can also consider other names like m_foo_bar, mi_foo_bar, m.foo_bar, m->foo_bar, m::foo_bar, using mi = mono_internal; mi::foo, foo.bar(), etc.

* [test] Report dlsym failure with an assertion failure and give the symbol.

* Compilation of external-only.c/.o needs special care.
Because it is dead code, except for exports, the linker does not necessarily eagerly look into it (.o within .a), and export anything. This is the usual behavior of Windows linker. Unix linker I guess it varies between programs and shared libraries, but it was observed and broke a test, and a small case was constructed to demonstrate the behavior (i.e. where the dlsym assert is added), even though I assumed the opposite -- so must be program vs. sharedlibrary.

Therefore, we `#include external-only.c` in object.c.

Longer term we should probably use Windows .def files and their Unix equivalent, and/or be sure to list external-only.o directly on the link command line, instead of burying it in a static library.

.def files were used in the past and have other advantages/differences.

Other than guaranteeably reaching into .a/.lib files to find exports, they also export on NT/x86 as plain "mono_foo" instead of "_mono_foo", easing portability of LoadLibrary / GetProcAddress.
The loss of the x86 C name mangling *could* be viewed as a loss, of a tiny amount of safety.

They also make declspec(dllimport) and declspec(dllexport) both pointless, at least for C functions -- dllimport remains significant for data and C++ (no need to list mangled names in .def file), and to microoptimize one instruction out of some calls on non-LTCG builds.
2018-10-22 14:03:05 -07:00
Johan Lorensson f2d67cd299 Windows BTLS assembler build support (cygwin/msvc). (#11234)
* Add support for BTLS assembler build on Windows (cygwin/msvc).

Building BTLS with assembler support on Windows requires several
additional build tools (except cmake) for both cygwin/msvc builds.
On cygwin, perl and yasm will be needed and on msvc, ninja, perl
and yasm. On msvc builds BTLS doesn’t support Visual Studio generator
when building with assembler support, so this commit adds support for
ninja build system covering that scenario. This commit adds support for
auto detection of needed build tools and enable assembler builds if all
needed tools have been identified as available. Commit also fixes the
execution of msbuild on CI to just use the original PATH variable instead
of the cygwin PATH to make sure correct version of identified build tools
gets used (Windows version of git, ninja, perl and yasm). Both cygwin and
msvc build will use nasm compiler (through use of yasm) since generated
assembler won’t compile with mingw’s gcc version.

* Bump BTLS commit.

* Fix a couple of warnings on BTLS build.

* Fix failing certificate import test using BTLS on Windows.

Mono BTLS library assumes all passwords are ANSI encoded strings since
SafePasswordHandle gets passed directly through pinvokes. This is only true for
SafePasswordHandle implemented on Unix:es. On Windows, SafePasswordHandle stores
passwords as Unicode, most likely due to Windows Crypto API accepting Unicode
passwords. When using BTLS on Windows this difference submerged since passwords
passed to BTLS will be Unicode encoded failing the decryption of PCKS12 structure.

Keeping the pattern already in place, passing SafePasswordHandler all the way
through pinvokes, the needed conversion will be done just before calling into OpenSSL
library as part of mono's BTLS library adapter.
2018-10-22 15:58:52 -04:00
Jay Krell ab17f4555d Fix warnings about unprototyped icalls and duplicate typedefs. (#11298) 2018-10-22 11:03:06 -07:00
Alexis Christoforides 412d35bd79 [class] Ensure 'cast_class' is initialized for array type classes. (#11268)
* [class] Ensure 'cast_class' is initialized for array type classes.

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

Background: Monoclass:cast_class is used internally to allow for some interfaces to be assignable to each other if they share a "storage class" instead of the class's element class. This is used to i.e. implement IList<ulong> being assignable from IList<long> (IList<ulong> has cast_class=long)

Consider a GenericClass<T> with a T[] field. On instantiation with e.g. GenericClass<ulong> , the ulong[] array class will be generated. As above, ulong[] has cast_class=long
When mono_class_init() is called on an array class, its element_class is also initialized.
If GenericClass<T>:Method() uses any type/subtype checking (e.g. if (field is double[]) ), those may attempt to use cast_class, which is not ensured as initialized.

* Fix typo

Co-Authored-By: alexischr <[email protected]>
2018-10-22 13:16:11 -04:00
Bernhard Urban c2c178c111 [ci] run regression tests with AOT (#11092) 2018-10-22 17:53:23 +02:00
Zoltan Varga 14b061ba65 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 08:45:43 -04:00
Zoltan Varga bf6a1edf75 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 07:08:54 -04:00
Zoltan Varga 299ae7a84e [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 07:08:38 -04:00
Zoltan Varga 54503ed970 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 07:08:14 -04:00
Zoltan Varga a7f448ad32 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 07:08:00 -04:00
Zoltan Varga 479a90be29 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 07:07:45 -04:00
Bernhard Urban b969364b7d [ci] run regression tests with AOT (#11092) 2018-10-22 12:46:20 +02:00
Zoltan Varga 5c5aef6164 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 04:06:26 -04:00
Zoltan Varga d58bf0bf41 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 04:06:03 -04:00
Zoltan Varga d7705f3fa5 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 04:05:40 -04:00
Zoltan Varga af0f521891 [jit] Profiler argument handling changes (#10885)
[jit] Profiler argument handling changes
2018-10-22 04:05:17 -04:00
Zoltan Varga 2b029b3df4 [jit] Profiler argument handling changes (#10885)
* [jit] Add support for accessing method arguments in the profiler in llvmonly mode, by generating code to store them into the MonoProfilerCallContext.args array.

* [jit] Use ctx->args instead of ctx->context for accessing arguments in the profiler.

* Update after review comments.

* [jit] Switch --trace to use the profiler infrastructure.

* Fix a rebase problem.

* Fix c++ failures.
2018-10-22 02:20:39 +02:00
Zoltan Varga aa670c98cb [wasm] Fix AOT support. (#11291)
* [wasm] Fix the creation of runtime.js in ninja mode.

* [wasm] Exit with an error code if the emscripten runtime hits an abort.

* [wasm] Error out when mono_wasm_load_runtime () fails too.

* [wasm] Wrap some code in ENVIRONMENT_IS_SHELL.

* [aot] Emit runtime invoke wrappers for up to 40 parameters for bitcode, newly added tests depend on it.

* [aot] Fix a buffer overflow in mini_get_gsharedvt_out_sig_wrapper_signature ().

* [wasm] Remove some filesystem code which is no longer needed.

* [wasm] Disable coop gc on the cross compiler, it effects the generated code.

* [wasm] Use a different random device under wasm so we can override its behavior. This is needed because /dev/random no longer works in emscripten 1.38.13 in JS shells.

* [wasm] Bump emscripten to 1.38.13.

* [wasm] Print a stack in one more abort case.

* [wasm] Add putchar to EXPORTED_FUNCTIONS, llvm-lto seems to create references to it after linking.
2018-10-21 22:44:43 +02:00
Alexander Köplinger 6a8a2059bb [Microsoft.Build.Engine] Fix race condition in TestTasks.dll compilation and embedding (#11275)
Since we've started embedding test resources inside of the test assembly
we've sometimes seen a strange error on Jenkins during the test run:

```
Msg: Error initializing task StringTestTask: Could not load file or assembly 'Microsoft.Build.Utilities.Core, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies.
Msg: Error initializing task StringTestTask: System.TypeLoadException: Could not load file or assembly 'Microsoft.Build.Utilities.Core, Version=14.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a' or one of its dependencies.
  at (wrapper managed-to-native) System.RuntimeType.GetConstructors_native(System.RuntimeType,System.Reflection.BindingFlags)
...
```

However this was from an xbuild_12 run so how come it tried to load xbuild 14 stuff?

The reason is there's a race condition between when TestTasks.dll gets
built and when it's embedded inside of the test assembly.

If we're building the xbuild_12 and xbuild_14 profile at the same time
we could end up embedding the xbuild_14 version of TestTasks.dll instead
of the correct one since we're copying it to the same file name.

The fix is to remove the unnecessary copying logic since we can just tell
the compiler to embed the file under the correct name.
2018-10-21 02:09:37 +02:00
Vlad Brezae 4a6b11577f [aot] Reenable recursion checking when initing shared got entries (#11258) 2018-10-20 12:37:59 +02:00
Jay Krell 0a2b2b7b21 Disable direct x86 aot tailcalls. Except to self. (#11282)
FullAOT is hypothetically ok, but FullAOT has other problems (https://github.com/mono/mono/issues/11276).

This addresses https://github.com/mono/mono/issues/11265.
This regressed presumably https://github.com/mono/mono/commit/f5373adc8a89d4b0d1d549fdd6d9adc3ded4b400.
2018-10-19 23:44:00 -07:00
Jay Krell f87470806d Fix recently introduced warning. (#11257) 2018-10-19 23:47:51 +02:00
Bernhard Urban b104565ccf [interp] use unsigned conversion for nuint (#11259)
[interp] use unsigned conversion for nuint

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-19 17:25:33 -04:00
Jay Krell 44db64c620 Typesafe coop handles for all platforms. (#11012)
This is an alternative or precursor to https://github.com/mono/mono/pull/10212.

 - Removes the dependency of some ABIs passing a pointer and a pointer in a struct the same.
 - Therefore gives all platforms the same type safety.
 - *If* we move to C++, allows us to have member functions in coop handles.
 -  Having the coop signatures available in C can provide  benefits, though we should 
    probably generate them from reading metadata -- though they won't match w/o more changes,
    since we mixup types in several places, like IntPtr vs. pointers.

JIT now traffics in old type-unsafe handles, and wrappers are generated with C preprocessor to trivially convert.
 This way the JIT doesn't have to pass structs by value here, which was tried/failed.

The C preprocessor machinery can/should be extended for additional gains.
In particular driving managed/native coop icall transitions from 3+ per call to 1 (like https://github.com/mono/mono/pull/10212).

That will require better verification of the signatures in icall-def.h, either automated and en masses or gradually manually. Embedders will likely do something else, or at least have to independently invent similar.

Whereever a native function was exposed via multiple managed names, wrappers are reused.
2018-10-19 14:13:28 -07:00
Aleksey Kliger (λgeek) eaaf83ef92 [runtime] Don't init classes in ves_icall_RuntimeTypeHandle_is_subclass_of (#11227)
We must not get a TLE if referenced types are in an assembly that can't be
loaded.

Fixes https://github.com/mono/mono/issues/11123
2018-10-19 14:11:31 -04:00
Kenneth Pouncey 85493320e7 [wasm] Fix Sample.html so sample will run (#11242)
* [wasm] Sample program in wasm sdks does not run.

- Add `mono-config.js` reference to html file.

resolves: https://github.com/mono/mono/issues/11239

* Fix `runtime.js` to reference `mono-config.js` variables.

* Fix packager.exe where it deletes the `runtime.js`.

- Replaced the File Delete and Copy with a Copy if new call.
- re-add the generation of a skeleton  `runtime.js` file if one can not be found.
2018-10-19 20:08:56 +02:00
Alexander Köplinger e48ca0d4cc [Mono.Debugger.Soft] Fixed spaces vs. tabs in Makefile 2018-10-19 20:04:50 +02:00
monojenkins 86941b00c1 [WinForms] Propagate the flags from DrawTextInternal to MeasureTextInternal (#11262)
Flags to DrawText never reached MeasureText therefore strings with '&' were measured incorrect when drawn with flag TextFormatFlags.NoPrefix.
Fixes #6352
2018-10-19 18:09:53 +02:00
Alexander Köplinger 2d8839e704 [System] Don't throw NIE for ServicePoint.ConnectionLeaseTimeout and .ReceiveBufferSize (#11246)
* [System] Don't throw NIE for ServicePoint.ConnectionLeaseTimeout and .ReceiveBufferSize

Instead return a no-op value. This is the same behavior as .NET Core.

Fixes https://github.com/dotnet/standard/issues/642

* Bump API snapshot submodule
2018-10-19 17:48:23 +02:00
Alexander Köplinger 2c1e5292f5 Bump corefx submodule
MemberInfoTests.cs moved from System.Runtime -> System.Reflection
2018-10-19 13:37:43 +02:00
Eberhard Beilharz 5fa2df8b4d [metadata] Fix crash related to custom attributes (#10739)
* [tests] Renumber duplicate return codes

* [metadata] Fix crash related to custom attributes (#10737)

When a class doesn't contain the desired custom attribute we used
to return the last available attribute. This prevented
`cominterop_ccw_queryinterface()` to detect that the interface
isn't implemented and lead to a crash.

This change fixes #10737.

* [cominterop] Switch to GC Unsafe in IUnknown and IDispatch impls

These methods can be called directly from embedding APIs.
2018-10-19 07:03:25 -04:00
Ludovic Henry aa5438dd5d [sdks] Package what's missing for XA (#11253)
They require the additional files:
 - mono/eglib/eglib-config.h: that's to build `libmonodroid`
 - mcs/build/Consts.cs: that's to build `Mono.Posix` and `Mono.Data.Sqlite`
2018-10-19 06:57:31 -04:00
Rodrigo Kumpera 2ae12c6a0a [wasm] Fix provision-wasm to do emsdk selection. Remove the need for the emcc patch. (#11250)
[wasm] Fix provision-wasm to do emsdk selection. Remove the need for the emcc patch.
2018-10-19 04:45:41 -04:00
Vlad Brezae 7a40ab148d [interp] Remove mint_type uses at execution time (#11167)
It is too slow. Check during transform whether the class is stored on vtstack or not.
2018-10-19 10:27:00 +03:00
Kenneth Pouncey dd7ac9ddd6 Fix Duplicate assemblies in config.js file_list: [ ... ] (#11236)
resolves: https://github.com/mono/mono/issues/11187
2018-10-19 02:28:23 -04:00
Alexander Kyte 9aab5273dd Add crash reporting debugger event (#10628)
This should help get information on native crashes that happen in hard-to-debug environments. 

To quote https://github.com/mono/mono/issues/10157 : 


When a mono runtime is attached to a managed debugger and the debugged runtime is induced to cause a crash, the state of that crash is not communicated to the managed debugger. This, combined with the difficulty in having the debugged runtime both attached to the managed debugger and lldb, makes this type of crash difficult to interactively debug.

When the managed debugger is the only connection someone has with the runtime because it is embedded in a way that is resistant to unmanaged debugging (watchOS application on-device, for instance), this is an even more difficult problem.

By adding an SDB protocol event that sends a type of "runtime death" and a blob of opaque json (version dependent, no protocol guarantees), people can report these crashes without having to assist a mono runtime engineer in observing a crash on device.

In the case that spurious bugs in this manner are submitted, it will require less effort as well to spot stack frames that indicate misuse of mixed managed-unmanaged APIs (which offer the ability to drive a segfault or g_assert
2018-10-19 02:39:03 +02:00
Alexis Christoforides 4844ab019d [corlib] Import System.IO.UnmanagedMemoryStream from CoreFX (#11210)
* [corlib] Import System.IO.UnmanagedMemoryStream from CoreFX

* Bump API snapshot submodule

* [csproj] Update project files
2018-10-18 18:34:38 -04:00
Ludovic Henry bdebfe93fb [tests] Embed Mono.Data.Sqlite test resource (#11244) 2018-10-18 18:30:49 -04:00
Zoltan Varga ab18dea99b [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.
2018-10-18 23:11:31 +02:00
Jay Krell d16869c510 Remove a few raw pointers, correct some signatures, remove some unnecessary handles(). (#11211)
* Mark AddRefInternal as NOHANDLES(). Its signature was incorrect.

* Change ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal to NOHANDLES.

* Mark ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal NOHANDLES.

* ves_icall_System_Runtime_InteropServices_Marshal_BufferToBSTR to nohandles().

* ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR to nohandles().

* ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal nohandles().

* ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem nohandles().

* Fix the signature of ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMemSize.

* [coop] Remove most uses of out_of_memory_ex.
2018-10-18 22:27:03 +02:00
Ludovic Henry cb616340d0 [pipeline] Ensure only 1 build per-product is executed per-node (#11247) 2018-10-18 22:09:16 +02:00
Alexander Köplinger 229a4673d4 [ci] Move OSX .pkg build to a separate bot pool
Allows us to better utilize the bockbuild cache.
2018-10-18 16:36:01 +02:00
Alexander Köplinger d07ddffffe [Mono.Debugger.Soft] Simplify building dtest-app.exe for monodroid profile (#11229)
We only build it if we're explicitly building the monodroid profile and for the
monodroid_tools profile we only build the test assembly but not dtest-app.exe
2018-10-18 13:06:27 +02:00
Alexis Christoforides 660ca3bc70 [corlib] Ensure that Console Streams are thread-safe (#11205)
The Console class wraps the standard system stream reader/writers on construction so as to expose them as thread-safe. However, the Set-Out/In/Err methods in referencesource do not do the same when they replace default targets.

CoreFX code does: https://github.com/mono/corefx/blob/1748f6492e8b96842f76e1a9e7b5d7e8ccfca480/src/System.Console/src/System/Console.cs\#L412-L444

Possible fix for https://github.com/mono/mono/issues/11146
2018-10-17 17:10:40 -04:00
Martin Baulig 95017ad9e4 Add myself as code owner of mono/native and some managed code. (#11228)
- `mono/native`
- `/mcs/class/corlib/Mono` (dependency injector, mono native, pal, certificates)
- `mcs/class/corlib/System.Security.Cryptography.X509Certificates`
- `/mcs/class/System/Mono` (PAL, certificates and dependency injector)
- `/mcs/class/System/System.Security.Cryptography.X509Certificates`
2018-10-17 21:26:47 +02:00
Ludovic Henry a282040c96 [bcl] Build all XUnit and NUnit tests for monodroid, monotouch, monotouch_tv, monotouch_watch and wasm BCL profiles (#11201) 2018-10-17 14:44:45 -04:00
Vlad Brezae 2b64076769 [aot] Ensure shared got entries are initialized before loading methods (#11190)
Executing aot code that uses them would crash. Fixes random csc crashes.
2018-10-17 14:21:45 -04:00
Egor Bogatov 2a250915c4 [corlib] Add xunit tests for BitConverter, Convert, etc (#10758)
* Add System.Runtime.Extensions tests

* ignore Environment.UserDomainName.cs

* bump corefx
2018-10-17 07:45:55 -07:00
HebaruSan b286fe3d74 Fix MessageBox text color for dark themes (#11196)
## Problem

`MessageBox` displays as black-on-dark in a dark theme:

![image](https://user-images.githubusercontent.com/1559108/47039608-f64f2580-d149-11e8-9c1d-1dd8d99d4cb8.png)

This can be difficult to read.

## Cause

The text is drawn with a hard coded color of `Color.Black`. This assumes that the background under the text will be light to contrast with black.

## Changes

Now the color is `SystemColors.ControlText` instead, to match the background of the popup.

In a normal theme this will still be black.
2018-10-17 14:10:17 +02:00
Alexander Köplinger a2f0c286af [pkg] Add preinstall which removes existing Mono of the same version (#11203)
Fixes https://github.com/mono/mono/issues/11202
2018-10-17 12:50:11 +02:00
Alexander Köplinger 237482628a Bump api-snapshot 2018-10-17 12:35:34 +02:00
Johan Lorensson b2d0e7e8a6 Merge pull request #11100 from lateralusX/lateralusX/build-btls-msvc
Build BTLS on Windows, Visual Studio.
2018-10-17 08:39:55 +02:00
Alexander Köplinger efd6c05aef Upstream a few test related commits from my Helix work (#11197)
* [bcl] Run System.Windows.Forms.DataVisualization tests

* [bcl] Run Mono.Messaging.* tests

* [bcl] Use correct label for mdoc tests

* [runtime] Skip verifying an xunit-binaries assembly
2018-10-17 03:48:49 +02:00
Jay Krell 99c3c9ba32 Fix cygwin configure error message to match scripts/ci. (#11151) 2018-10-17 01:54:12 +02:00
Bernhard Urban 965aebf500 [ppc] fix UCONTEXT_REG macros for FreeBSD (#11128)
Contributed by @lenoil98. Fixes https://github.com/mono/mono/issues/11020
2018-10-17 01:49:47 +02:00
Alexis Christoforides d3769a73ff [corlib] Import System.IO.IOException from CoreFX (#11102)
* [corlib] Import System.IO.IOException/FileLoadException from CoreFX

* [corlib] Remove unused string

* [corlib] Remove another test assert for BadImageFormatException

Exception message no longer includes the file name
2018-10-17 01:38:30 +02:00
Alexander Köplinger 0fad97f2f3 [wasm] Use latest Microsoft.AspNetCore.App in ProxyDriver.csproj 2018-10-16 23:10:53 +02:00
Alexander Köplinger 74687a0a63 Remove azure-pipelines.yml
It was an experiment
2018-10-16 22:50:08 +02:00
Alexander Köplinger 6c7790d0a8 Move CODEOWNERS to .github folder
So all GitHub related special files are in one place
2018-10-16 21:28:05 +02:00
Martin Baulig b61a3ffb02 [System]: Reenable native Apple Certificate support on WatchOS. (#11173)
During the code refactoring this summer, support for native apple certificates
has been dropped on watchOS.

* add `apple-certificates.sources` and move all certificate-related code from
  `appletls.sources`.

* move non-network related code from `MacProxy` into a new `AppleTypes`.

* add the `MONO_FEATURE_APPLE_X509` magic to `System/Makefile` where it was missing from.
2018-10-16 20:57:09 +02:00
Ludovic Henry 2a4cfddd9a [sdks] Build tests for BCL targets (#11141)
* [sdks] Build BCL profiles without configure flags

* [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] Simplify call to BclTemplate

* [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
2018-10-16 14:00:12 -04:00
Jonathan Chambers 36edb2f275 Take fast path only for delegate types not Delegate/MulticastDelegate. (#11182) 2018-10-16 13:14:32 -04:00
Alexander Köplinger 7a505f2e40 [mcs] Fix platform-specific build of "build" profile and remove more remnants of the "basic" profile (#11185)
The platform specific build got lost in 8d8fd97dbf but we need it for monolite. The remnants of the "basic" profile are no longer needed.
2018-10-16 19:12:13 +02:00
Ludovic Henry 0fd450ac6b [sdks] Add Groovy script to build the SDKs archives for the products (#11137) 2018-10-16 11:03:51 -04:00
Zoltan Varga 0beb087567 [WIP] [wasm] AOT work. (#11071)
* [runtime] Fix the signature of some native type tests.

* [runtime] Add stubs for the ves_icall_System_Net_NetworkInformation_MacOsIPInterfaceProperties_ParseRouteInfo_internal () icall, needed for AOT.

* [wasm] Print a native stack trace on asserts.

* [wasm] Avoid mmaps with zero length, it leads to an exception under emscripten.

* [bcl] Preserve CustomAttributeData:.ctor (), its called from the runtime.

* [wasm] Print out full test names in the test runner.

* [wasm] Preserve System.Threading.WasmRuntim.

* [wasm] Rename config.js to mono-config.js

* [wasm] Add targets to build aot versions of the test suites.

* [wasm] Exit with a nonzero exit code in case of a failure.

* [wasm] Disable crash reporting.

* [wasm] Use mono headers for public functions.

* [wasm] Enable building AOT tests on CI.

* [wasm] Run some AOT test suites on CI.

* [runtime] Make MonoBundledAssembly.size non-const.

* [wasm] Add a --setenv=VARIABLE=VALUE argument to runtime-tests.js which allows the setting of environment variables.

* [wasm] Update cross compiler executable name.

* [wasm] Remove unused aot-driver.js file, runtime-tests.js has the same functionality.

* [wasm] Run mini tests with AOT on CI.

* [wasm] Error out if the linker fails.

* [wasm] Fix building the AOT tests from another directory.

* [wasm] Use a matching Mono.Cecil.dll for the linker.

* [wasm] Fix running aot tests on CI.

* Revert "[sdks] Switch the invocation of the offsets too to 64 bit on osx. (#10903)"

This reverts commit 2989a83f23.

This seems to cause failures on linux+webassembly.
2018-10-16 10:29:29 +02:00
monojenkins b71a4b76bb [sdks] futimens and futimes symbols are missing on anything earlier than 10.13 (#11179)
This breaks when LLVM is built on 10.13+ and the runtimes are built on 10.12.
2018-10-15 23:02:41 -04:00
Martin Baulig f973c6d90f [System] Make a test compile on mobile. (#11175) 2018-10-16 01:12:14 +02:00
Jay Krell d30c8649f1 mono_field_get_type to mono_field_get_type_internal to skip GC mode machinery (#11082)
But also optimize mono_field_get_type in the common case, to "short circuit"
and skip ditto.
2018-10-16 00:40:43 +02:00
Alexander Kyte 2d415fa1b3 [crash] Split unmanaged method pointers into method ip + offset (#11142)
The VS4M team is making a tool that makes a symbolication lookup table. This enables symbolication without access to the relevant binary. 

For unmanaged, it's much harder to precompute things because we were presenting the instruction address. From the address, any lookup needs to find the function enclosing this interior pointer.

To make it easier, this reports the address of the native method as well as the offset. A lookup table can simply key on the function start address with this now. 

ie:

  ``` 
      {
        "native_address" : "0x1003a6340",
        "native_offset" : "0x00046",
        "native_module" : "mono"
      }
```

 ```
$ nm mini/mono-sgen | grep '1003a6340' 

00000001003a6340 t _mono_runtime_run_main_checked

```

```
$ nm mini/mono-sgen | grep ' t ' | sort -n

00000001000a4e90 t _alloc_ireg
00000001000a4eb0 t _decompose_long_opcode
00000001000aae90 t _mono_decompose_long_opts
00000001000aaea0 t _mono_decompose_vtype_opts
00000001000ae130 t _m_class_get_byval_arg
00000001000ae150 t _alloc_dreg
............
```
2018-10-16 00:39:37 +02:00
Jay Krell c105cd2339 Remove GC mode transitions from mono_array_length, and replace with mono_array_length_internal. (#11122) 2018-10-15 14:07:58 -07:00
Alexander Kyte 1bc31b3ab1 [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.
2018-10-15 13:12:50 -04:00
Alexander Kyte aef45d547e [crash] Print half-completed dump when space runs out 2018-10-15 13:12:50 -04:00
Martin Baulig 51548b4d37 Initial Mono.Native Support. (#10596)
`Mono.Native` is the new name for both `System.Native` and `System.Security.Cryptography.Apple`.
It is built as a stand-alone shared library and not bundled with the runtime because we
may need to build two different versions of it.

Starting with macOS 10.12+ and iOS 10+, Apple introduced a new Unified API for some of the
crypto primitives that we're using as part of System.Security.Cryptography.Apple.

On Desktop, we can check at runtime whether the OS version is recent enough and switch
implementation accordingly.  We build a single `libmono_native` shared library.

However, on Mobile we cannot have any undefined symbols as this would break Bitcode.

During the mobile build, we are called with `CC` containing an explicit minium version flag,
which is either `-mmacosx-version-min=`, `-mios-simulator-version-min=` or `-miphoneos-version-min=`
depending on platform.

We build two versions of the shared library:
- `libmono_native_compat` is built with whichever minimum version is passed to us via `CC`.
- `libmono_native_unifed` is built with the minimum version set to macOS 10.12+ / iOS 10+.

For testing purposes, there is a function called `mono_native_get_platform_type ()`
(see mono/native/mono-native-platform.c), which returns a `MonoNativePlatformType` enum value.
There is also `Mono.MonoNativePlatform.GetPlatformType ()` (see mcs/class/corlib/Mono/MonoNativePlatform.cs).

This can be called by automated tests both to ensure that the library has been correctly installed and also
to verify that it's the correct version of it.

* `configure.ac`: add new configure checks for Mono.Native.

* `mono/native/`: new directory - this replaces the `System.Native` code that was previously in `mono/metadata`.

* `mcs/class/corlib/Mono`: New internal `MonoNativePlatformType` and `MonoNativePlatform` classes.
2018-10-15 17:38:45 +02:00
Alexander Köplinger 2ebb5efed5 Fix comment in RemoteExecutorTestBase.Mono.cs 2018-10-15 17:21:36 +02:00
lateralusX 360620a68a Additional checks for correct environment when doing msvc BTLS builds. 2018-10-15 16:51:44 +02:00
lateralusX c77084dcb8 Add lib prefix of msvc build BTLS library. 2018-10-15 14:51:22 +02:00
lateralusX d5e38af6c7 Fix BTLS build warnings on Windows. 2018-10-15 14:45:24 +02:00
lateralusX dd3e2cd0c7 Fix case insensitive compares. 2018-10-15 14:45:24 +02:00
lateralusX f8249e65be Add vcxproj to build btls as part of regular mono msvc build. 2018-10-15 14:45:24 +02:00
lateralusX 1678b9cbae Bump external/boringssl commit. 2018-10-15 14:45:23 +02:00
lateralusX c1d38347cb Build script for btls using msvc. 2018-10-15 14:45:23 +02:00
lateralusX 9761c65ae8 Fix mono btls build using msvc 2015/2017. 2018-10-15 14:45:23 +02:00
Alexander Köplinger 8d1dd6aa65 Fix Mono.Debugger.Soft to use test exe's from different directory (#11033)
And make it work for the monodroid_tools profile.
2018-10-15 14:12:19 +02:00
monojenkins fa79aa7e8b Merge pull request #11127 from lewurm/mono-ppc-sigill
[ppc] use G_BYTE_ORDER in order to define patch_load_sequence

Fixes https://github.com/mono/mono/issues/11021
2018-10-15 03:35:35 -04:00
Zoltan Varga 2989a83f23 [sdks] Switch the invocation of the offsets too to 64 bit on osx. (#10903) 2018-10-15 04:50:54 +02:00
Marek Safar 2e5d1bbe82 [metadata] Remove unused type caches 2018-10-14 08:27:44 -07:00
Maxim Lipnin 5c4e4c5084 Add check for empty string to correctly get constructors in case of name="*" 2018-10-12 18:22:08 -07:00
Maxim Lipnin 081ca12f82 [Reflection] Fixing bugs in MonoParameterInfo caught by xunit tests (#11052)
This PR fixes the bugs caught by [RawDefaultValue](https://github.com/mono/corefx/blob/411def5f278956f3c514c02ab76d9bb89428fef7/src/System.Runtime/tests/System/Reflection/ParameterInfoTests.cs#L22) and [VerifyParameterInfoGetRealObjectWorks](https://github.com/mono/corefx/blob/411def5f278956f3c514c02ab76d9bb89428fef7/src/System.Runtime/tests/System/Reflection/ParameterInfoTests.cs#L91) tests
2018-10-12 18:12:49 -07:00
monojenkins 232ed99c1c Bump API snapshot submodule 2018-10-12 18:00:46 -07:00
Zoltan Varga e5b4c144ac Fix checking the contents of the sourcelink file on windows. 2018-10-12 18:00:46 -07:00
Zoltan Varga 7f81c2776f [sdb] Add support for reading the sourcelink data from portable pdb files using a new SourceLink property on ModuleMirror objects.
Fixes https://github.com/mono/mono/issues/10038.
2018-10-12 18:00:46 -07:00
Bernhard Urban e5504fb8ea [mini helpers] strip more directives on arm (#11124)
* `-s` removes all symbols.
* `-x` removes non-global symbols.

This is needed in order to get human readable output with `MONO_VERBOSE_METHOD=method`, so instead of:

```
Disassembly of section .text:

00000000 <.text>:
   0:   e92d4900        .word   0xe92d4900
   4:   e24dd05c        .word   0xe24dd05c
   8:   e1a0b00d        .word   0xe1a0b00d
   c:   e58b0030        .word   0xe58b0030
  10:   e58b1034        .word   0xe58b1034
[...]
```

It is this now:
```
Disassembly of section .text:

00000000 <.text>:
   0:   e92d4900        push    {r8, fp, lr}
   4:   e24dd05c        sub     sp, sp, #92     ; 0x5c
   8:   e1a0b00d        mov     fp, sp
   c:   e58b0030        str     r0, [fp, #48]   ; 0x30
  10:   e58b1034        str     r1, [fp, #52]   ; 0x34
[...]
```

This is needed due to a newer toolchain on our ARM bots. Tested on armv7 and aarch64.
2018-10-12 17:23:33 -04:00
Jay Krell 697e959c6f mono_class_from_mono_type to mono_class_from_mono_type_internal to skip GC mode machinery (#11078) 2018-10-12 12:24:17 -07:00
Bernhard Urban ddf734ee52 [ppc] use G_BYTE_ORDER in order to define patch_load_sequence
Fixes https://github.com/mono/mono/issues/11021
2018-10-12 17:22:52 +02:00
Kenneth Pouncey c3999baa3d [wasm] Add support for Module.locateFile to runtime loading (#11101)
* [wasm] Fix the build.

* [wasm] Add --copy parameter to packager

- copy parameter

```

        --copy=always|ifnewer        Set the type of copy to perform
                              'always' overwrites the file if it exists.
                              'ifnew' copies or overwrites the file if modified or size is different.

```

- Fix wasm build target in do-runtime target.

* [wasm] Add support for Module.locateFile to runtime loading

See issue https://github.com/mono/mono/issues/11099 for more information.

resolves issue: https://github.com/mono/mono/issues/11099

* Fix spelling of option `ifnew` to `ifnewer`
2018-10-12 10:59:57 -04:00
Jay Krell ec623e581e Replace MONO_CLASS_IS_INTERFACE with MONO_CLASS_IS_INTERFACE_INTERNAL to avoid gc mode transitions. (#11112) 2018-10-12 07:58:04 -07:00
Jay Krell 51ebea7a48 mono_method_signature to mono_method_signature_internal to skip GC mode machinery (#11080) 2018-10-12 01:18:06 -07:00
monojenkins 656c820cf9 [2018-08] Bump msbuild (#11098) 2018-10-11 17:35:22 -04:00
Martin Baulig 3baefe7ef1 Build BTLS on Windows, cygwin/mingw. (#9306)
* Build BTLS on Windows.

* Quote more cmake paths

Should fix issue on Windows build where cmake is installed in C:\Program Files

* Fix btls cygwin x86, x64 Windows build.

NOTE, cygwin btls build depends on cygwin installed cmake, update cygwin
install to include cmake before building.

* Disable BTLS as default for Windows builds.
2018-10-11 17:25:13 -04:00
Vlad Brezae 431628cad7 [interp] Implement interpreter entry trampolines on amd64 (#10978)
* [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-11 17:18:30 -04:00
Bernhard Urban 15ae6a97ad [exceptions] continue program execution when mapping of stack overflow guard page fails (#11064)
* [exceptions] continue program execution when mapping of stack overflow guard page fails

Related: https://github.com/mono/mono/issues/10415

* turn comment into warning

* fix mono_gc_register_altstack call when no guard page is mapped
2018-10-11 17:16:17 -04:00
Bernhard Urban 288b9b0f95 [tests] lower recursion depth of PerformNoPinAction (#11065)
so it doesn't overflow the stack when running on macOS with `clang -O0`.
2018-10-11 17:15:54 -04:00
Jay Krell 0d308e5e9a x86 mono_arch_get_patch_offset: add support for 0xe9/jmp eip+32b. (#11089)
I don't know what the specific code is or what changed, etc.

This addresses Mac/x86:

https://jenkins.mono-project.com/job/test-mono-pull-request-i386-osx/15364/parsed_console/log.html

```Unable to compile method 'int Tests:calli_sig_check_2 ()' due to: 'Invalid IL code in Tests:calli_sig_check_2 (): IL_000b: calli     0x11000044```

which then fails an assert and fails overall.

CI goes deep into bash w/o echoing commands but a repro is:

 cd mono/mini
 MONO_PATH=./../../mcs/class/lib/net_4_x lldb -- ./mono --aot iltests.exe

The code is meant to be invalid, and meant to raise an exception,
which is catchable/resumable (at least in the JIT case where
executing IL the first time, can raise an exception while caller is
running, vs. AOT where the codegen all happens offline -- leaving what?
A note made at AOT time that calling the code should raise an exception?).

It isn't meant to fail an assert in either case.
2018-10-11 16:46:09 -04:00
Alexander Kyte c3fe80a0c4 [crash] Crash Reporter V2 (#10532)
This change set represents a major set of changes to the crash reporting mechanism. 

1) Coordination involving mandatory timeouts and signals have been changed greatly, to instead use semaphores and to end waiting as soon as possible. 

2) Dumping of unmanaged symbols outside of mono has been made possible. Embedders that want to get information on frames outside of mono-sgen can register the library with an icall. This carefully preserves both privacy (opt-in) and resiliency (can't crash/lose more info when misused).

3) The dumper has moved from a workflow that kills the runtime after a long delay into one that can dump individual threads or the entire runtime in a prompt manner. The runtime doesn't die at the end of the dump, but allows threads to resume what they were doing and returns to the caller. 

4) This has allowed for the addition of a number of tests that stress both parallel and concurrent dumping of threads. These run fairly quickly, and leave the runtime in a state to continue testing. 

5) With this lightweight testing setup created, a long burn-in testing period was done. Places we were using locks or trying to malloc resulted in crashes or hangs. After making the needed changes, it managed to run the dumping tests in a loop for a whole weekend on a Linux x64 configuration without any problems.

This has resulted in a dumper with dramatically improved stability and performance.
2018-10-11 16:38:21 -04:00
Zoltan Varga 92ebd1793b [wasm] Fix the build. (#11063) 2018-10-11 16:33:37 -04:00
Jay Krell 2c3ad9d458 mono_class_enum_basetype to mono_class_enum_basetype_internal to skip GC mode machinery. (#11079) 2018-10-11 12:13:23 -04:00
Jay Krell b77c6a6885 mono_class_is_assignable_from to mono_class_is_assignable_from_internal to skip GC mode machinery (#11081)
FIXME mono_class_is_assignable_from_checked
2018-10-11 09:48:16 -04:00
Jay Krell 70208087df Replace mono_object_get_class with mono_object_class to avoid gc transitions. (#11077) 2018-10-11 09:47:53 -04:00
Alexander Kyte 6b9b24c583 [runtime] Fixup stacktrace creation on s390x (#11073)
* [runtime] Fix mismatched parenthesis on exc-s390x

* [runtime] Fix mismatched static function type declaration on s390x

* [runtime] Fixup b7c18caf0c for s390x
2018-10-10 17:25:44 -04:00
Alexander Kyte b4067405d3 [runtime] Fix internal llvm (#11074)
The makefile uses $(dir $<) which has `../` and so refers to `llvm/external/llvm` rather than `external/llvm` now that we're using llvm from a submodule in external/
2018-10-10 15:46:31 -04:00
monojenkins fb7ad92db9 Merge pull request #11053 from BrzVlad/fix-interp-static-field
[interp] Optimize static field access

Do most of the work on transform side and include the field address in the instruction stream. We need to run cctor at runtime to preserve expected order. This makes static field access 4 times faster.



<!--
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-10 13:25:41 -04:00
Aleksey Kliger 6161324629 Example experiment "null" 2018-10-10 11:54:14 -04:00
Aleksey Kliger 8a0fbd4e89 Add --enable-experiment= and MONO_EXPERIMENT= support
Experiments are unsupported and provide no stability or backward compatability
guarantees.
2018-10-10 11:54:14 -04:00
Marek Safar 8d8fd97dbf [build] Unify bootstrap profiles (#11024)
* [build] Unify bootstrap profiles

We can now rely on build only as we have reliable monolite and package
compilers

* Fixes genproj dependencies

* [csproj] Update project files
2018-10-10 08:49:38 -07:00
Maxim Lipnin 831e73abcd [Reflection] Unify exception param name 2018-10-09 18:02:24 -07:00
Maxim Lipnin 98db98fe06 [Reflection] Handle overflow exception on constructor invocation (#11028)
It allows to re-enable  [Invoke_OneDimensionalArray_NegativeLengths_ThrowsOverflowException](https://github.com/mono/corefx/blob/master/src/System.Reflection/tests/ConstructorInfoTests.cs#L96) test and enable [TestInvoke_1DArrayWithNegativeLength](https://github.com/mono/corefx/blob/master/src/System.Runtime/tests/System/Reflection/ConstructorInfoTests.cs#L79) test.

Fixes https://github.com/mono/mono/issues/10024
2018-10-09 16:59:12 -07:00
monojenkins 53f4861c2d [csproj] Update project files 2018-10-09 16:33:53 -07:00
monojenkins d44969b5c4 Bump API snapshot submodule 2018-10-09 16:33:53 -07:00
Maxim Lipnin 58dd6ac196 Disable GetTypeTests.cs 2018-10-09 16:33:53 -07:00
Maxim Lipnin 88c68600e6 [Reflection] CoreFX import for TypeDelegator type 2018-10-09 16:33:53 -07:00
Aleksey Kliger fdfd781b4a Always use InvariantCulture calendars in X509Certificate on Mobile
Allow the linker to remove UmAlQuraCalendar and HijriCalendar on mobile devices

Match the CoreFX X509Certificate changes: https://github.com/mono/corefx/commit/4eb1fc2abd2ffa70e402d22415d0209b21725a10

Fixes https://github.com/mono/mono/issues/10448
2018-10-09 15:47:26 -07:00
Jay Krell d4c0479362 [icalls] Declare all icalls correctly. (#11019)
It is hacky to have to avoid includes in order to have conflicting/incorrect declarations.

And hacky to use extern "C" when the reason is to have incorrect prototypes.

It is arguably hacky to suppress the gcc warning -- granted, the functions are never called, and merely their addresses taken and put into void* -- arguably gcc's warning is too strict and should only trigger for calls or taking address into a non-void*.

Arguably the declarations should be moved around the tree.

Perhaps we should omit the prototypes from C++.
2018-10-09 13:27:49 -04:00
Jay Krell b477d7dad8 [icall] Add InOut handles. Use InOut handles and Out handles more correctly. (#11042)
This is only an unenforced naming convention.
2018-10-09 13:27:28 -04:00
Zoltan Varga 1d71454132 [arm64] Pass small stack args correctly on linux. Fixes pinvoke.exe with llvm+full aot. (#10674)
* [arm64] Pass small stack args correctly on linux. Fixes pinvoke.exe with llvm+full aot.

* Bump llvm.
2018-10-09 11:37:54 -04:00
Bernhard Urban e357ef7ae8 Bump corefx
Commit list for mono/corefx:

* mono/corefx@17e9259f14 [tests] add finalizer helper to avoid false pinning (#156)
* mono/corefx@4eb1fc2abd Remove calendary dependency from X509Certificate

Diff: https://github.com/mono/corefx/compare/411def5f278956f3c514c02ab76d9bb89428fef7...17e9259f147d9b4b32394d249bf2b7aa1673e406
2018-10-09 11:33:12 -04:00
Zoltan Varga 65e207ba7c [wasm] AOT work. (#10989)
* [llvm] Fix the icall signature of a few llvm EH icalls.

* [wasm] Disable com/remoting in the linker.

* [wasm] Enable direct icalls.

* [wasm] Generate the configuration into a config.js file instead of rewriting the runtime.js file.

* [wasm] Enable icall symbol map in the cross compiler, compile the device runtime with -fexceptions.

* [wasm] Rename runtime-tests.g.js -> runtime-tests.js.

* [wasm] Add mono_wasm_assembly_get_entry_point () function to obtain the entry point of an assembly.

* [wasm] Add profiler support to the packager.

* [wasm] Add support for running a normal .net executable to the test runner.
2018-10-09 11:32:20 -04:00
Vlad Brezae 78455914e8 [interp] Optimize static field access
Do most of the work on transform side and include the field address in the instruction stream. We need to run cctor at runtime to preserve expected order. This makes static field access 4 times faster.
2018-10-09 17:38:39 +03:00
Ludovic Henry a618a1a9ea [sdks] Add cmake toolchain file for LLVM MXE builds (#11008)
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-09 08:14:20 -04:00
Egor Bogatov ed50d2560a Depend on all *_test.dll.sources for make run-test (#11030)
* depend on all test.sources for `make run-test`

* fix typo (to exclude xunit tests)
2018-10-08 21:31:03 -04:00
Ludovic Henry 8b7d80396e [llvm] Add as a submodule (#11010) 2018-10-08 18:27:20 -04:00
Alexander Köplinger a8d007e51d AOT: use 32 bit flags for as/ld when targetting x86 on linux (#11032)
So it works when running the 64bit as/ld on the host with a 32bit mono binary.
2018-10-08 18:24:04 -04:00
Jay Krell 6b3cb0d93b [Coop] Convert mono_object_clone_checked, mono_object_new_from_token, mono_class_create_runtime_vtable, mono_runtime_object_init_checked. (#11018)
* [coop] Optimize mono_runtime_object_init_handle -- don't pin non-valuetypes.

* [coop] Convert mono_runtime_object_init_checked to call mono_runtime_object_init_handle.

* [coop] Convert mono_class_create_runtime_vtable.

* [Coop] Convert mono_object_new_from_token.

* [coop] Convert mono_object_clone_checked.
2018-10-08 11:36:30 -07:00
Ludovic Henry c6ddea6c06 [mcs] Fix dependencies on mcs/class/lib/<Profile>/tests/<Profile>_corlib_test.dll.nunitlite.config (#11029)
The directory mcs/class/lib/wasm/tests wouldn't necessarily be created before we would try to copy the file to it.
2018-10-08 12:42:17 -04:00
Rodrigo Kumpera df46658fd1 [wasm] Unbreak the debugger and harden it against bad assemblies. (#11011)
* [wasm] Harden the debugger against invalid breakpoints.

This happens when you reload a page and the old BPs land in now invalid code regions.

* Add node support to library_mono.js

* [wasm] Correctly register pdb files.
2018-10-08 12:08:23 -04:00
Ludovic Henry 58228c24fa [sdks] Build Android SDKs archive in Debug configuration on master builds (#11007)
* [sdks] Build Android SDKs archive in Debug configuration on master builds

* [sdks] Drop `product-` prefix from Android and iOS SDKs CI_TAGS parameters
2018-10-08 11:46:52 -04:00
Zoltan Varga c7c89f2155 [llvm] Fix the loaded llvm build. (#11014) 2018-10-08 11:06:05 -04:00
Jay Krell b7c18caf0c Significant disambiguation between host and target. (#10969) 2018-10-08 10:38:35 -04:00
Jay Krell 58925baab1 [icalls] Change gboolean to MonoBoolean. (#11017) 2018-10-08 10:37:37 -04:00
Calvin Buckley 0d29dfb9dd Mitigation for spawn FD closing taking forever with a big FD limit (#10761)
* Mitigation for spawn FD closing taking forever with a big FD limit

On systems with a large file descriptor limit, Mono takes a very
long time to spawn a new process; with informal testing on the AIX
CI builder, (with a POWER7) it took ~30 minutes. This is obviously
very undesirable, but hand our is forced - libraries the user might
be calling could be creating non-CLOEXEC files we're unaware of. As
such, we started from the FD limit and worked our way down until we
hit stdio. Using APIs such as posix_spawn aren't desirable as we do
some fiddling with the child before we exec; and even then, closing
FDs with posix_spawn relies on non-standard file actions like
Solaris' addclosefrom not present on many systems. (All of this is
unnecessary on Windows, of course.)

This presents an alternative way (currently only implemented on AIX
but with notes how for other platforms) to try to close the child's
loose FDs before exec; by trying to get the highest number FD in
use, then work our way down. In the event we can't, we simply fall
back to the old logic.

See #6555 for a discussion and the initial problem being mitigated.

* Use an another strategy of closing only known to be open handles

...on FreeBSD and AIX.

Use the kinfo_getfiles library call on FreeBSD and only close what's
safe to close. On AIX, use the third and fourth arguments to getprocs
to check what's open. However, the array to get all the handles takes
1 MB, so allocate it on the heap; like what kinfo_getfiles does. We
don't need to free these as the child will exec or exit, which blows
it all away.

The previous strategy from previous commit is still used and on AIX,
enhanced.

* Add Linux strategy to fork FD close

Tested on WSL, shows benefits with big FD ulimit.
2018-10-08 08:31:29 -04:00
monojenkins a756fa0f4a [csproj] Update project files 2018-10-08 10:03:28 +02:00
Marek Safar cd5135022b Bump linker 2018-10-08 10:03:28 +02:00
Marek Safar 539b148920 [linker] Adds more tests 2018-10-08 10:03:28 +02:00
monojenkins e64d8aaa72 Bump API snapshot submodule 2018-10-08 10:02:16 +02:00
Marek Safar 6ca0889b3c [build] Fixes Mono.Cecil boostrap dependency 2018-10-08 10:02:16 +02:00
Marek Safar 0b003f9fa4 Bump cecil 2018-10-08 10:02:16 +02:00
Marek Safar 6070870c2d [build] Update XI facades to build against reference assemblies (#10980)
Clean up facades to build remaining ones in parallel
2018-10-07 16:37:41 -04:00
Ludovic Henry d319f72d0d [sdks] Fix wasm order-only dependency on .PHONY target (#11009) 2018-10-05 20:26:37 -04:00
Jay Krell 31c90d2817 [icalls] Replace gboolean and mono_bool by MonoBoolean. (#10948)
Though one of these is an enum, use gint32.

The enums MonoResolveTokenError and MonoProtocolType are also used in icalls, but that is left alone.
2018-10-05 21:33:06 +02:00
Jay Krell bf11fbd8d3 ifdef HAVE_ARRAY_ELEM_INIT is not actually guarding code that uses C99 array (#10996)
initialization, but rather code that is portable to C89 and C++98.

The alternative is also ok, just costs typically a pointer and a relocation per array element,
things most people wouldn't notice but was presumably the point here.
2018-10-05 21:20:16 +02:00
Alexander Köplinger 67390ef6f4 Bump corefx 2018-10-05 18:24:10 +02:00
Alexis Christoforides b8ccd4071f [corlib] Fixup for System.IO.MemoryStream CoreFX import 2018-10-05 10:49:14 -04:00
Ludovic Henry 0c776d5a9e Bump to llvm/release_60/117a508c (#10983) 2018-10-05 09:49:35 -04:00
Rodrigo Kumpera b42a6a83ad Merge pull request #10962 from kumpera/another_vtable_bug
[runtime] Properly inflate cmods of (m)var.
2018-10-05 09:26:50 -04:00
monojenkins 7d18d3d660 [bcl] Update BCL Linked Size 2018-10-05 09:39:25 +02:00
Ankit Jain 2fbfadbd9c Bump msbuild to track xplat-master (#10339) 2018-10-05 09:13:22 +02:00
Alexander Kyte 7d56ecc42c [crash] Make stub for rethrow_preserve_exception on aarch64 2018-10-05 02:04:59 -04:00
Alexander Kyte 7ca584cdc3 [crash] Fixup field name typo on untested arches (#10990) 2018-10-05 00:04:19 +02:00
Rodrigo Kumpera 84b6e89300 [aot] Add clangxx option to --aot (#10779)
* [aot] Add clangxx option to --aot that removes the hardcoded clang++ in our aot compiler.

* [mini] Make --aot addictive.

* Update CI script for bitcode.
2018-10-04 17:18:28 -04:00
Alexander Kyte dcdbf3aafc [runtime] Fix malformed string selection in exceptions-ppc.c (#10987) 2018-10-04 22:14:02 +02:00
Maxim Lipnin ab0099d393 Bump corert 2018-10-04 21:54:05 +02:00
Maxim Lipnin 90cc835df8 Bump corert 2018-10-04 21:54:05 +02:00
Maxim Lipnin 3d24f0ba99 Extract case for verifying several object array parameters to separate test method. 2018-10-04 21:54:05 +02:00
Maxim Lipnin bc4d1a18ed Add unit tests to verify custom attribute ctor with object array as parameter 2018-10-04 21:54:05 +02:00
Alexander Köplinger 8b90cefc79 Fix corefx submodule ref 2018-10-04 19:42:35 +02:00
monojenkins 3568d3648e [csproj] Update project files 2018-10-04 19:01:44 +02:00
monojenkins 0627919d75 Bump API snapshot submodule 2018-10-04 19:01:44 +02:00
Alexis Christoforides 83ad1cb3d8 [corlib] Import System.IO.MemoryStream from CoreFX 2018-10-04 19:01:44 +02:00
Rodrigo Kumpera 577ab741b2 Make a bunch of classes optional to the runtime. (#10804)
The makes the following classes optional to the runtime:

System.Reflection.CustomAttributeData
System.Text.StringBuilder
System.Math
System.Console
System.Diagnostics.StackTrace

Those are all types that can be clearly made optional. There are a lot of other types
we could, but there are deeper dependencies in places as threadpool or marshal.

* [runtime] Kill mono_defaults.console_class.

* [runtime] Kill mono_defaults.asyncresult_class. Doesn't help much as it's still needed by the TP.

* [runtime] Remove mono_defaults.stack_trace_class.

* [runtime] Remove dead field.

* [runtime] Remove mono_defaults.math_class

* [runtime] Cleanup handleref resolution to use the access macros.

* [runtime] Remove mono_defaults.stribuilder_class.

* [runtime] Remove System.Reflection.CustomAttributeData

* [corlib] Update linker description.

* [runtime] Fix compilation of the iOS SDK.
2018-10-04 18:21:40 +02:00
Alexander Köplinger d9fabd0501 [tests] Remove magic which prepends MonoTests to NUnit test selection (#10977)
When passing FIXTURE or TESTNAME to "make run-test" we automatically
prepended `MonoTests.` to the value since all of our NUnit tests
start with that to save you from typing a few chars.

Now that we have xUnit tests as well this is confusing since it doesn't
happen there. Better to remove it for consistency.
2018-10-04 17:05:25 +02:00
Alexander Köplinger 42e347ee47 [corlib] Simplify confusing "SSPI" error message and align with corefx (#10976)
Right now if anything goes wrong in the security stack you get a message like this:

```
System.Security.Authentication.AuthenticationException: A call to SSPI failed, see inner exception. ---> Mono.Btls.MonoBtlsException: Ssl error:1000007d:SSL routines:OPENSSL_internal:CERTIFICATE_VERIFY_FAILED
```

This is confusing since SSPI is a Windows-only thing and is not used on Mono.
We inherited this error message string from referencesource.

Change the string to something more generic which also aligns us with CoreFX:
https://github.com/dotnet/corefx/blob/a10890f4ffe0fadf090c922578ba0e606ebdd16c/src/System.Net.Security/src/Resources/Strings.resx#L210-L212
2018-10-04 17:04:58 +02:00
Alexander Köplinger b13145bb12 [ci] Always pass sha1 from Mac to Windows packaging build
Before we only did this for PR builds but it turns out it's needed for
normal master/branch builds too.

In situations where there are two Mac builds at roughly the same time
the downstream Windows builds would otherwise both refer to the same/latest
commit since they just checkout the latest ref on the branch.

Now we reset the Windows build to the sha1 which is passed to it.
2018-10-04 14:21:59 +02:00
Kenneth Pouncey a7f5952c69 [wasm][bindings] Add support for strongly typed marshalling of C# enums. (#10958)
* Add support for strongly typed marshalling of C# enums.

JavaScript does not have the concept of Enums like TypeScript.  Strings are used to represent enums.  This PR allows a strongly type contract between C# values and the string representations used by a lot of the JavaScript API's.

Example:

DOM InputElement type ->  https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#attr-type#Form_<input>_types

    The InputElement types are represented by strings.  button, checkbox, color, date, datetime-local etc....

     These string can be represented and marshalled back and forth by defining an enum as shown below with an `Export` data contract attribute.

```
    public enum InputElementType
    {
        [Export(EnumValue = ConvertEnum.ToLower)]
        Button,
        [Export(EnumValue = ConvertEnum.ToLower)]
        CheckBox,
        [Export(EnumValue = ConvertEnum.ToLower)]
        Color,
        [Export(EnumValue = ConvertEnum.ToLower)]
        Date,
        [Export("datetime-local")]
        DateTimeLocal,
   }

```

The enum conversion allows controlling the marshalling:

- Default - Marshals the enum name as is
- ToLower - Marshals the enum name to lower case string
- ToUpper - Marshals the enum name to upper case string
- Numeric - Marshals the enum numeric values.

Marshalling from C# to JavaScript using the SDK Bindings should be made as easy and pain free as possible.

Marshalling the string values from JavaScript to C# will need a little help.  The SDK Bindings Runtime provides a method to transport the string value to a strongly typed enum.

```
   WebAssembly.Runtime.EnumFromExportContract(typeof(InputElementType), inputElementType);
```

* Add marshalling of C# Enums to method calls.

* Add tests to bindings-test harness for testing marshalling of C# enum values.

* Modify test for marshalling enum value without Export contract.
2018-10-04 11:44:05 +02:00
monojenkins 385b8a2783 Merge pull request #10749 from lewurm/interp-fixes-for-native-type
[interp] fixes for native types

please look at single commits.

------------------------

[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.

-----------------------

[interp] support ntype.CompareTo ()

-----------------------

[interp] support ntype.Equals ()

-----------------------

 [interp] support nfloat.*Infinity

-----------------------

[interp] support ntype.ToString ()

-----------------------

The conversion issue creeped everywhere in Xamarin.iOS since it heavily relies on nint/nuint/nfloat. With this PR we are getting close to a green monotouch tests 😁 
<img width="874" alt="screen shot 2018-09-21 at 23 24 36" src="https://user-images.githubusercontent.com/75403/45907566-b457eb80-bdf8-11e8-9cc7-b8cf311dd269.png">

needs backporting to 2018-06 and 2018-08
2018-10-04 11:25:35 +02:00
HebaruSan 0c2543cecf Fix default colors for DataGridView (#10944)
* Fix default colors for DataGridView

* Update tests
2018-10-04 10:54:56 +02:00
Egor Bogatov 895bf51b0c Use Mono.Android as a reference for netstandard facade (#10849)
* bump external/binary-reference-assemblies

* use Mono.Android for netstandard

* use API_BIN_REFS

* move ifeq monodroid upper

* use Mono.Android in System.Drawing.Primitives instead of ns

* fix typo

* Add Mono.Android back to ns as API_BIN_REFS

* Bump API snapshot submodule

* [csproj] Update project files
2018-10-04 10:39:21 +02:00
monojenkins 8d8587f4bc [bcl] Update BCL Linked Size 2018-10-04 09:32:05 +02:00
Alexander Kyte 19fbbda478 Merge pull request #10468 from alexanderkyte/fix_stacktrace
[runtime] Fix stored exception throws
2018-10-04 03:31:30 -04:00
Alexander Kyte e46fa20466 [crash] Fix trampoline rethrows to set caught_in_unmanaged 2018-10-03 17:11:04 -04:00
Rodrigo Kumpera e32462ed7d [mini] Add regression test for #10834. 2018-10-03 13:35:59 -04:00
Rodrigo Kumpera ccaf6a86dc [metadata] Make type dup used by inflate_generic_type be cmod aware. Fixes #10834
We didn't include cmods when inflating var/mvar cuz we'd mono_metadata_type_dup' the inflated type
and not the (m)var MonoType.

The solution is to add a variant of mono_metadata_type_dup that takes the source of cmods to use.
2018-10-03 13:25:29 -04:00
Rodrigo Kumpera 517be3d557 [metadata] Improve --print-vtable when dealing with broken types or abstract methods. 2018-10-03 13:23:28 -04:00
Bernhard Urban 7c61df97a8 [interp] introduce float R4 stack type 2018-10-03 16:57:32 +02:00
Bernhard Urban bdae608a88 [interp] support ntype.ToString () 2018-10-03 16:56:59 +02:00
Bernhard Urban 5f41720a4d [interp] support nfloat.*Infinity 2018-10-03 16:56:58 +02:00
Bernhard Urban 4cccb0dda9 [interp] support ntype.Equals () 2018-10-03 16:56:58 +02:00
Bernhard Urban 6a759dbcd4 [interp] support ntype.CompareTo () 2018-10-03 16:56:58 +02:00
Bernhard Urban bffb1163df [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-03 16:56:58 +02:00
Vlad Brezae ffb4f021bf [interp] Avoid emitting some unnecessary opcodes (#10894) 2018-10-03 10:50:27 -04:00
Rolf Bjarne Kvinge 5501111e8a [sdks/ios] Build libMonoPosixHelper for device architectures, so that zlib-helper.o is created. (#10921)
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-03 10:46:47 -04:00
monojenkins 0eea315727 Merge pull request #10672 from jaykrell/fault-addr-wasm.3
Get fault_addr in debugger stacks.

This time w/o breaking WebAssembly and w/ working on Mac.
2018-10-03 15:35:52 +02:00
Alexander Köplinger 6ad08fff9e [bcl] Put xunit tests in mcs/class/lib/PROFILE/tests too (#10928)
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.
2018-10-03 12:16:19 +02:00
Aleksey Kliger fbf43a4266 [linker] Bump to mono/linker@e6760e6f
Includes mono/linker@4dde7af5c8
to fix permissions of files created by OutputStep.

Fixes https://github.com/mono/mono/issues/10743
2018-10-03 10:27:51 +02:00
Maxim Lipnin 4905422666 [Reflection] Fix issue with finding types in module using an asterisk as filter criteria 2018-10-03 08:45:49 +02:00
Paul Hebble 7d52f0fb7e Paint ToolStrip background with ToolStrip.BackColor 2018-10-03 08:42:40 +02:00
monojenkins 82e573122a [csproj] Update project files 2018-10-03 08:38:19 +02:00
monojenkins dc42f1562f Bump API snapshot submodule 2018-10-03 08:38:19 +02:00
Marek Safar 6bcccccb82 [corlib] Control SRE using its own define 2018-10-03 08:38:19 +02:00
Marek Safar 4c20744e2a [corlib] Updates PNSE version of DynamicMethod to have matching APIs 2018-10-03 08:38:19 +02:00
Johan Lorensson c82567b6c9 Merge pull request #10646 from lateralusX/lateralusX/issue10508-diag
Fix scheduling problem related to thread-suspend-suspended and thread-suspend-selfsuspended.
2018-10-03 08:31:53 +02:00
monojenkins 8f9d781f8c [bcl] Update BCL Linked Size 2018-10-03 08:25:25 +02:00
Ludovic Henry def2d9e550 [sdks] Use make --output-sync=recurse on CI (#10939)
When building the SDKs on CI, the output is very scrambled. There are simultaneously outputs from making multiple runtimes, uncompressing some tar archives, cloning some repos, building various BCL profiles, etc. This makes it quite hard to easily understand what's going wrong when the build fails.

By using `--output-sync=recurse`, we make sure that even if many targets are executed in parallel, the output is still as if it was executed sequentially.
2018-10-02 23:42:05 -04:00
Ludovic Henry bc6d91e992 Update azure-pipelines.yml 2018-10-02 23:07:03 -04:00
Ludovic Henry cd3974f221 Update azure-pipelines.yml 2018-10-02 22:56:10 -04:00
Ludovic Henry d216896999 Update azure-pipelines.yml 2018-10-02 22:55:40 -04:00
Ludovic Henry 17ac875028 Update azure-pipelines.yml 2018-10-02 22:52:32 -04:00
Ludovic Henry 9072200e08 Update azure-pipelines.yml 2018-10-02 22:45:13 -04:00
Ludovic Henry f7c77c35f0 Update azure-pipelines.yml 2018-10-02 22:38:18 -04:00
miguel f824e73d2f [AzureDevOps] Move to Ubuntu 2018-10-02 22:36:53 -04:00
miguel 4f27bfe066 Update 2018-10-02 22:36:03 -04:00
Ludovic Henry 9e570bc053 Update azure-pipelines.yml 2018-10-02 22:34:16 -04:00
Ludovic Henry ee90fb094e Update azure-pipelines.yml 2018-10-02 22:25:26 -04:00
Miguel de Icaza 708af8c15e Set up CI with Azure Pipelines
Barebones script for the dev.azure.com/mono-project pipeline setup.
2018-10-02 22:20:59 -04:00
Aleksey Kliger (λgeek) c0d72ca8cb [w32handle] Add coop state transitions in mono_w32handle_lock_handles (#10910)
If another thread locked at least one of the other handles, and there is a
cooperative GC STW happening, this function will loop forever.

Add GC Safe transitions around the call to sleep to give this thread a chance
to suspend.

Fixes https://github.com/mono/mono/issues/10863
2018-10-03 00:03:49 +02:00
Vlad Brezae 84ec74a9f0 [runtime] Fix undefined pthread_main_np (#10930)
It is exported only when _DARWIN_C_SOURCE is defined.
2018-10-03 00:00:59 +02:00
Ludovic Henry 6dcc779e17 [sdks] Build llvm-llvm{,win}{32.64} on Linux on CI as well (#10937) 2018-10-02 16:53:02 -04:00
Martin Baulig f0921fd850 Use passwordless import in the X509Certificate(byte[]) constructor.
The `X509Certificate(byte[])` constructor should call `CertificateProvider.Import(byte[])`
to use the native apple implementation if possible.

Add temporary hack to `X509Certificate2(byte[])` to ensure that we always get an
`X509Certificate2Impl`.
2018-10-02 17:21:58 +02:00
Marek Safar 2b6eae3912 [linker] Reenable accidentally disabled test 2018-10-02 16:30:49 +02:00
Rodrigo Kumpera f399693f63 [metadata] Improve --print-vtable. 2018-10-02 10:24:08 -04:00
Rodrigo Kumpera 28dbdb4217 [metadata] Extract print_vtable_layout_result. 2018-10-02 10:24:03 -04:00
Rodrigo Kumpera 0919c6fd90 [metadata] print just the assembly name when dumping the vtable. 2018-10-02 10:23:59 -04:00
Ludovic Henry a67333b58f [sdks] Ensure LLVM is cloned before trying to download (#10913) 2018-10-02 08:53:24 -04:00
Maxim Lipnin f04b43a44d [Reflection] Fix the issue with ToString method in MonoCMethod type (#10901)
Fixes https://github.com/mono/mono/issues/10838.

The new behavior is similar to coreclr's one: https://github.com/dotnet/coreclr/blob/af4ec7c89d0192ad14392da04e8c097da8ec9e48/src/System.Private.CoreLib/src/System/Reflection/RuntimeConstructorInfo.cs#L145
2018-10-02 14:29:49 +02:00
Alexander Köplinger e9de4af4d4 [ci] Remove workaround for libtiff issue
We recently updated libtiff, let's see if this is still required
2018-10-02 13:31:09 +02:00
Jay Krell b07aab167f Restore typecheck to corlib version check, so that mixing
old integer with new string errors w/o crash.
2018-10-02 11:19:27 +02:00
Alexander Köplinger 634e726bdf [packaging] Remove installation of openssl via brew on macOS (#10874)
We're now using an msbuild version which uses .NET Core 2.x which no longer needs openssl.
2018-10-02 11:10:23 +02:00
Alexander Köplinger 6145ad25fc Merge pull request #10912 from akoeplinger/test-precompile
[mcs] Fix test compilation to use common target and refactor mono-symbolicate test building
2018-10-02 11:09:35 +02:00
monojenkins d31c926a74 [bcl] Update BCL Linked Size 2018-10-02 10:45:43 +02:00
Maxim Lipnin c22ac963e9 [System.Reflection] CoreFX import for TypeInfo type (#10871)
* [System.Reflection] CoreFX import for TypeInfo type

* Bump corefx

* Bump corefx

* Bump API snapshot submodule

* [csproj] Update project files
2018-10-02 10:35:43 +02:00
Kenneth Pouncey d02ecf72b6 [wasm] Update sample.cs usage and docs (#10847)
* Fix problem with HttpClientHandler not returning the response status text if available when there is an http error.

resolves: https://github.com/mono/mono/issues/10842

* Extend C# sample to include:

- Calling JavaScript functions from C#
- Calling C# functions from JavaScript.
- Referencing JavaScript objects
- Getting and Setting JavaScrip object properties.
- Invoking JavaScript object functions.
- Setting up the default HttpClientHandler
- Instantiating a default WasmHttpMessageHandler.
- Setting up HttpClient calls
- Parsing and testing the correct results returned from the HtppClient.
- Obtaining a byte array and string array from response.
- Obtaining a reference to a global script function defined in the .html file and calling it.
- Working with DOM objects using the SDK's WebAssembly.Bindings.dll

resolves: https://github.com/mono/mono/issues/7548

* Update sample usage docs
2018-10-02 10:33:04 +02:00
Jay Krell f246511f38 [cxx] Do not define C++ keywords: bool, inline, final, it can break things. (#10883)
* [cxx] Do not define C++ keywords: bool, inline, final, it can break things.

https://jenkins.mono-project.com/job/d/421/parsed_console/log.html

  C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\include\xkeycheck.h(250): fatal error C1189: #error:  The C++ Standard Library forbids macroizing keywords. Enable warning C4005 to find the forbidden macro. [d:\j\workspace\d\msvc\libmonoruntime.vcxproj]

* PR: Leave profiler defining C++ keywords (define bool char).
* PR: Restore libgc. (mainline removed the code in 2011).
2018-10-01 22:40:15 -07:00
Alexander Köplinger f782e36a80 [mcs] Fix test compilation to use common target
Add proper dependencies to the test support files where they were missing.
Compile test files using the standard "make test" target.
2018-10-02 02:08:07 +02:00
Alexander Köplinger a7d4c2a8b9 [mono-symbolicate] Refactor so test assets can be precompiled 2018-10-02 01:58:59 +02:00
Ludovic Henry 0aebe90cac [sdks] Create archive targets for pre-building on CI (#10882)
* [sdks] Remove redundant --enable-cxx

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

* [sdks] Build BCL profiles without configure flags

* [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] Create archive targets for pre-building on CI

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

* [sdks] Run archive-llvm-llvm{,win}{32,64} on CI
2018-10-01 17:43:46 -04:00
Vlad Brezae 9182bcccc3 [runtime] Disable stack guard for main thread on osx (#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
2018-10-01 16:37:16 -04:00
Alexander Kyte 52a9b776ea [runtime] Fix off by one with stacktrace rethrow 2018-10-01 14:23:48 -04:00
Jo Shields 6f8ca69401 Merge pull request #10898 from directhex/master
Bump version to 5.21.0
2018-10-01 12:05:05 -04:00
Jo Shields bb8a0ce8e7 Bump version to 5.21.0 2018-10-01 10:21:34 -04:00
lateralusX 51affb26bc Fix scheduling problem related to thread-suspend-suspended and thread-suspend-selfsuspended.
thread-suspend-suspended and thread-suspend-selfsuspended tests has showed long
execution times on low core Windows machines running wow64. It looks like an OS
related issue where ResumeThread Win32 API takes a lot longer time to complete
when running a test scenario like thread-suspend-suspended and this additional
time adds up over many iterations pushing it over to timeout. NOTE, the same behavior
has been identified running on .NET framework, so it's not a mono specific issue and
only reproduce under wow64 on low core machines (probably when one core is busy
just leaving us with one core for most of the test).

Since the purpose of the test is to run GC when t1 is suspended, doing this more
deterministic will fix the ResumeThread issue under wow64 on low core count as
well as making the tests more deterministic, always having t1 in a suspended state
when running GC (that will test the suspend suspended scenario).

Full investigation can be found in, https://github.com/mono/mono/issues/10508.
2018-10-01 16:15:10 +02:00
Alexander Kyte 2e15fa255f [runtime] Add test for icall wrapper rethrowing and exception length 2018-09-30 23:26:10 -04:00
Alexander Kyte cd1a48ef26 [runtime] Fix stored exception throws
On cooperative suspend, the wrapper frames capture the exception
in a MonoError, which then must be thrown. The problem with treating
it as a CIL THROW opcode is that every time you THROW, you completely
reset the stacktrace's collectin of saved frames.

The RETHROW opcode will force the JIT to rely on an in-flight exception,
that in our case has been taken our of the in-flight context.

By relying on the new MONO_RETHROW, we will take an explicit exception
and put it back in-flight without clearing the stored stacktrace.
2018-09-30 23:26:09 -04:00
Alexander Kyte 2cee721190 [runtime] Add mono_rethrow opcode 2018-09-30 23:26:09 -04:00
Jay Krell c76bacba17 Combine MONO_ATTRIBUTE_NO_OPTIMIZE and MONO_NO_OPTIMIZATION. 2018-09-18 10:27:33 -07:00
Jay Krell cb4d25dec2 Move MONO_SIG_HANDLER_DEBUG from mono/utils/mono-signal-handler.h to
mono/mini/mini-runtime.c so it can use the correct ifdefs
which should fix WebAssembly compilation and let it work on
Mac and Win32 also. This means we no longer need HOST_LINUX in configure.ac either.

Note that for Win32 we don't have the same sort of execution
of a debugger for this to help, but you can see it works
if you run in a debugger and break on mono_sigsegv_signal_handler_debug.
2018-09-18 10:24:18 -07:00
Jay Krell 7c191c1370 Get fault_addr in debugger stacks. 2018-09-18 09:35:35 -07:00
Jay Krell b690f2d3d1 Move signal handler stuff out of ifdef except MONO_SIG_HANDLER_INFO_TYPE since it was all the same. 2018-09-18 09:35:35 -07:00
Jay Krell 86ee99f6b3 Use MONO_SIG_HANDLER_INFO_TYPE in two places so that Win32 and Posix are otherwise identical. 2018-09-18 09:35:35 -07:00
Jay Krell 2aaeae2354 Provide MONO_ATTRIBUTE_NO_OPTIMIZE in mono-compiler.h. 2018-09-18 09:35:35 -07:00
4820 changed files with 482112 additions and 173051 deletions

No files matched your search

+4 -4
View File
@@ -13,11 +13,11 @@ mkinstalldirs crlf=input
*.h crlf
*.cs crlf
*.il crlf
*.sln crlf
*.*proj* crlf
# don't do anything to line-endings. Let CRLFs go into the repo, and CRLF on checkout
*.bat -crlf
*.sln -crlf
*.*proj* -crlf
# don't do anything to line-endings. Let CRLFs/LFs go into the repo, and CRLF/LFs on checkout
*.bat -crlf
*.xml -crlf
# CRLF Handling
+152
View File
@@ -0,0 +1,152 @@
# Mono Code Owners File
#
# GitHub uses this file to determine who to assign for reviews
# on pull requests. Please keep this file alphabetically sorted.
#
# References:
#
# https://github.com/blog/2392-introducing-code-owners
# https://help.github.com/articles/about-codeowners
# These owners will be the default owners for everything in the repo.
* @marek-safar
# Order is important. The last matching pattern has the most precedence.
/acceptance-tests @akoeplinger @kg
/acceptance-tests/profiler-stress* @alexrp @akoeplinger
/data @directhex @akoeplinger
/data/gdb @lewurm @vargaz
/data/lldb @lewurm @vargaz
/docs @marek-safar @akoeplinger
/docs/riscv.md @alexrp @lewurm
/docs/sources/mono-api-profiler.html @alexrp
/external @akoeplinger @marek-safar
/external/api-snapshot @marek-safar @akoeplinger
/external/binary-reference-assemblies @marek-safar @akoeplinger
/external/bockbuild @akoeplinger @alexischr
/external/boringssl @baulig
/external/cecil @marek-safar @akoeplinger
/external/corefx @akoeplinger @marek-safar @egorbo @alexischr
/external/corert @akoeplinger @marek-safar @egorbo @alexischr
/external/linker @marek-safar
/external/llvm @alexanderkyte @vargaz
/external/nuget-buildtasks @radical @akoeplinger
/external/roslyn-binaries @kg @marek-safar @akoeplinger
/libgc @BrzVlad @vargaz
/llvm @vargaz @alexanderkyte
/man @marek-safar @miguel
/man/*prof* @alexrp
/mcs @marek-safar @akoeplinger @egorbo
/mcs/build @marek-safar @akoeplinger
/mcs/class @marek-safar @akoeplinger
/mcs/class/corlib/System.Reflection*/ @vargaz @lambdageek
/mcs/class/corlib/System.Security.Cryptography.X509Certificates @baulig @marek-safar
/mcs/class/Mono.Btls.Interface @bauligg @marek-safar
/mcs/class/Mono.Data.Tds @egorbo
/mcs/class/Mono.Debugger.Soft @vargaz @thaystg
/mcs/class/Mono.Options @jonpryor @marek-safar
/mcs/class/Mono.Profiler.Log @lambdageek
/mcs/class/Mono.Security/Mono.Security/Interface @baulig @marek-safar
/mcs/class/System/Mono.AppleTls @baulig @rolf
/mcs/class/System/Mono.Btls @baulig @marek-safar
/mcs/class/System/Mono.Net.Security @baulig @marek-safar
/mcs/class/System/Mono.Security.Interface @baulig @marek-safar
/mcs/class/System/System.Security.Cryptography.X509Certificates @baulig @marek-safar
/mcs/class/System.Data* @egorbo @marek-safar
/mcs/errors @marek-safar @lewurm
/mcs/ilasm @marek-safar @lewurm
/mcs/jay @marek-safar @lewurm
/mcs/mcs @marek-safar @lewurm
/mcs/tests @marek-safar @lewurm
/mcs/tools @marek-safar @akoeplinger
/mcs/tools/gensources @kg @akoeplinger
/mcs/tools/resx2sr @baulig
/mcs/tools/upload-to-sentry @alexanderkyte @akoeplinger
/mono/arch @vargaz @lewurm
/mono/btls @baulig @marek-safar
/mono/dis @lambdageek @vargaz
/mono/eglib @vargaz @lambdageek
/mono/benchmark @alexanderkyte @lewurm
/mono/metadata @vargaz @lambdageek @thaystg
/mono/metadata/*profiler* @lambdageek
/mono/metadata/handle* @lambdageek @vargaz
/mono/metadata/monitor* @brzvlad @vargaz
/mono/metadata/sgen* @brzvlad @vargaz
/mono/metadata/thread* @lateralusX @lambdageek
/mono/metadata/w32* @lateralusX @lambdageek
/mono/metadata/*-win* @lateralusX @lambdageek
/mono/mini @vargaz @lewurm @lambdageek
/mono/mini/*cfgdump* @lewurm @vargaz
/mono/mini/*exceptions* @lewurm @vargaz
/mono/mini/*ppc* @lewurm @vargaz
/mono/mini/*riscv* @alexrp @lewurm
/mono/mini/*type-check* @lewurm @lambdageek
/mono/mini/interp/* @lewurm @BrzVlad
/mono/mini/*profiler* @alexrp @lambdageek
/mono/mini/debugger-agent.c @vargaz @thaystg @DavidKarlas
/mono/native @baulig @egorbo @alexischr @marek-safar
/mono/profiler @alexrp @lambdageek
/mono/sgen @BrzVlad @lambdageek
/mono/utils @vargaz @lewurm @lambdageek
/mono/utils/atomic* @lewurm @vargaz
/mono/utils/mono-hwcap* @lewurm @vargaz
/mono/utils/mono-mem* @lewurm @vargaz
/mono/utils/mono-threads* @lambdageek @vargaz
/mono/utils/*-win* @lateralusX @lambdageek
/msvc @lateralusX @kg @akoeplinger
/msvc/scripts @akoeplinger @kg
/netcore @marek-safar @akoeplinger @egorbo
/packaging @alexischr @akoeplinger @directhex
/packaging/MacSDK/msbuild.py @radical @akoeplinger
/runtime @akoeplinger @marek-safar
/samples @lambdageek @lewurm
/samples/profiler @alexrp @lambdageek
/samples/size @alexrp @lambdageek
/scripts @akoeplinger @directhex
/scripts/ci @akoeplinger @directhex
/sdks @marek-safar @lewurm @vargaz
/sdks/builds/android* @alexischr @jonpryor
/sdks/builds/mxe* @alexischr @jonpryor
/sdks/builds/ios* @vargaz @rolfbjarne
/sdks/builds/wasm* @vargaz @kjpou1 @lewing
/sdks/wasm @vargaz @kjpou1 @kg @lewing
/sdks/ios @vargaz @rolfbjarne
/sdks/android @alexischr @jonpryor
/support @lambdageek @vargaz
/tools @lambdageek @vargaz
/tools/locale-builder @marek-safar @egorbo
/tools/nuget-hash-extractor @marek-safar @radical @akoeplinger
/tools/offsets-tool @lewurm @rolfbjarne
/tools/pedump @lambdageek @lewurm
/tools/sgen @brzvlad @vargaz
+3
View File
@@ -89,6 +89,7 @@ stamp-h.in
*~
*.swp
*.o
*.dylib
.deps
.libs
@@ -132,3 +133,5 @@ tmpinst-dir.stamp
msvc/scripts/inputs/
extensions-config.h
*.mlpd
llvm/build/
llvm/usr/
+10
View File
@@ -58,3 +58,13 @@
[submodule "external/api-snapshot"]
path = external/api-snapshot
url = git://github.com/mono/api-snapshot.git
[submodule "external/llvm"]
path = external/llvm
url = git://github.com/mono/llvm.git
branch = release_60
[submodule "external/helix-binaries"]
path = external/helix-binaries
url = git://github.com/mono/helix-binaries.git
[submodule "external/illinker-test-assets"]
path = external/illinker-test-assets
url = git://github.com/mono/illinker-test-assets.git
-136
View File
@@ -1,136 +0,0 @@
# Mono Code Owners File
#
# GitHub uses this file to determine who to assign for reviews
# on pull requests. Please keep this file alphabetically sorted.
#
# References:
#
# https://github.com/blog/2392-introducing-code-owners
# https://help.github.com/articles/about-codeowners
# These owners will be the default owners for everything in the repo.
* @luhenry @marek-safar
# Order is important. The last matching pattern has the most precedence.
/acceptance-tests @akoeplinger
/acceptance-tests/profiler-stress* @alexrp
/data @marek-safar @akoeplinger @luhenry
/data/gdb @vargaz
/data/lldb @lewurm @vargaz
/docs @luhenry @marek-safar
/docs/sources/mono-api-profiler.html @alexrp
/external @marek-safar @luhenry
/external/binary-reference-assemblies @marek-safar @akoeplinger
/external/bockbuild @akoeplinger @alexischr
/external/boringssl @baulig
/external/nuget-buildtasks @radical @akoeplinger
/libgc @BrzVlad @vargaz @luhenry
/llvm @vargaz @luhenry
/man @marek-safar @miguel @luhenry
/man/*prof* @alexrp
/mcs @marek-safar @luhenry
/mcs/build @marek-safar @akoeplinger
/mcs/class @marek-safar @akoeplinger
/mcs/class/corlib/System.Reflection*/ @vargaz @lambdageek
/mcs/class/Mono.Btls.Interface @baulig
/mcs/class/Mono.Data.Tds @egorbo
/mcs/class/Mono.Debugger.Soft @vargaz
/mcs/class/Mono.Options @jonpryor
/mcs/class/Mono.Profiler.Log @alexrp
/mcs/class/Mono.Security/Mono.Security/Interface @baulig
/mcs/class/System/Mono.AppleTls @baulig
/mcs/class/System/Mono.Btls @baulig
/mcs/class/System/Mono.Net.Security @baulig
/mcs/class/System/Mono.Security.Interface @baulig
/mcs/class/System.Data* @egorbo
/mcs/errors @marek-safar
/mcs/ilasm @marek-safar
/mcs/jay @marek-safar
/mcs/mcs @marek-safar @lewurm
/mcs/tests @marek-safar
/mcs/tools @marek-safar @akoeplinger
/mono @luhenry
/mono/btls @baulig
/mono/dis @lambdageek @vargaz
/mono/eglib @kumpera @vargaz @luhenry
/mono/metadata @vargaz @kumpera
/mono/metadata/*verify* @kumpera
/mono/metadata/*profiler* @alexrp
/mono/metadata/monitor* @brzvlad
/mono/metadata/sgen* @brzvlad
/mono/metadata/threads* @luhenry @kumpera
/mono/metadata/threadpool* @luhenry
/mono/metadata/w32* @luhenry
/mono/metadata/*-win* @lateralusX @luhenry
/mono/mini @vargaz @kumpera
/mono/mini/*cfgdump* @lewurm
/mono/mini/*exceptions* @lewurm
/mono/mini/*ppc* @lewurm
/mono/mini/*type-check* @lewurm
/mono/mini/interp/* @lewurm @BrzVlad
/mono/mini/*profiler* @alexrp
/mono/mini/debugger-agent.c @DavidKarlas
/mono/profiler @alexrp @kumpera
/mono/sgen @BrzVlad @kumpera
/mono/utils @kumpera @vargaz
/mono/utils/atomic* @alexrp
/mono/utils/mono-hwcap* @alexrp
/mono/utils/mono-mem* @alexrp
/mono/utils/mono-threads* @luhenry @kumpera
/mono/utils/*-win* @lateralusX @kumpera
/msvc @lateralusX @luhenry
/msvc/*profiler* @alexrp
/msvc/scripts @akoeplinger @kg
/packaging/ @alexischr @akoeplinger @luhenry @directhex
/packaging/MacSDK/msbuild.py @radical @akoeplinger
/runtime @akoeplinger @marek-safar @luhenry
/samples @luhenry
/samples/profiler @alexrp
/samples/size @alexrp
/scripts @akoeplinger @luhenry
/scripts/ci @akoeplinger @alexischr
/scripts/ci/run-test-profiler-stress-tests.sh @alexrp
/sdks @marek-safar @luhenry
/sdks/builds/android* @luhenry @jonpryor
/sdks/builds/mxe* @luhenry @jonpryor
/sdks/builds/ios* @vargaz @rolfbjarne
/sdks/wasm @kumpera @lrz
/sdks/ios @vargaz @rolfbjarne
/sdks/android @luhenry @jonpryor
/support @luhenry @vargaz
/tools @kumpera @luhenry
/tools/checker @tritao
/tools/crash-bisector @kumpera
/tools/locale-builder @marek-safar
/tools/monograph @vargaz
/tools/nuget-hash-extractor @marek-safar
/tools/offsets-tool @lewurm @rolfbjarne
/tools/pedump @kumpera @lambdageek
/tools/sgen @brzvlad
-2
View File
@@ -28,8 +28,6 @@ Mono itself, and does not end up in the redistributable part of Mono:
* mcs/jay: 4-clause BSD licensed
* mcs/nunit24: MS-PL
* mcs/class/I18N/mklist.sh, tools/cvt.sh: GNU GPLv2
Runtime Code
+20 -7
View File
@@ -11,15 +11,22 @@ else
tools_dir = tools
endif
SUBDIRS = mk po $(libgc_dir) llvm mono $(ikvm_native_dir) support data runtime scripts man samples $(tools_dir) msvc $(docs_dir) acceptance-tests
if ENABLE_MSVC
build_with_msvc = msvc
build_without_msvc =
else
build_with_msvc =
build_without_msvc = msvc
endif
SUBDIRS = $(build_with_msvc) mk po $(libgc_dir) llvm mono $(ikvm_native_dir) support data runtime scripts man samples $(tools_dir) $(build_without_msvc) $(docs_dir) acceptance-tests
# Keep in sync with SUBDIRS
DIST_SUBDIRS = m4 mk po $(libgc_dir) llvm mono ikvm-native support data runtime scripts man samples tools msvc docs acceptance-tests
DIST_SUBDIRS = $(build_with_msvc) m4 mk po $(libgc_dir) llvm mono ikvm-native support data runtime scripts man samples tools $(build_without_msvc) docs acceptance-tests netcore
all: update_submodules
SUBMODULE_ERROR='Could not recursively update all git submodules. You may experience compilation problems if some submodules are out of date'
update_submodules:
@$(srcdir)/scripts/update_submodules.sh
@cd $(srcdir) && scripts/update_submodules.sh
.PHONY: update_submodules
@@ -50,8 +57,8 @@ dist-hook:
rm -f `find $(top_distdir)/external -path '*\.Plo'`
rm -f `find $(top_distdir)/external -name '\.dirstamp'`
rm -f `find $(top_distdir)/external -path '*\.exe' -not -path '*/roslyn-binaries/*'`
rm -f `find $(top_distdir)/external -path '*\.dll' -not -path '*/binary-reference-assemblies/*' -not -path '*/roslyn-binaries/*'`
rm -rf "$(top_distdir)/external/linker/linker/Tests"
rm -f `find $(top_distdir)/external -path '*\.dll' -not -path '*/binary-reference-assemblies/*' -not -path '*/roslyn-binaries/*' -not -path '*/helix-binaries/*'`
rm -rf "$(top_distdir)/external/linker/test"
pkgconfigdir = $(libdir)/pkgconfig
noinst_DATA = mono-uninstalled.pc
@@ -66,9 +73,15 @@ if BITCODE
BITCODE_CHECK=yes
endif
if DEFAULT_TESTS
CI_TEST_SCRIPT=$(srcdir)/scripts/ci/run-test-default.sh
else
CI_TEST_SCRIPT=$(srcdir)/scripts/ci/run-test-$(TEST_PROFILE).sh
endif
.PHONY: check-ci
check-ci:
MONO_LLVMONLY=$(BITCODE_CHECK) $(srcdir)/scripts/ci/run-test-$(TEST_PROFILE).sh
MONO_LLVMONLY=$(BITCODE_CHECK) $(CI_TEST_SCRIPT)
.PHONY: validate do-build-mono-mcs mcs-do-clean mcs-do-tests
validate: do-build-mono-mcs
+1
View File
@@ -4,3 +4,4 @@ Makefile
*.dll
*.mdb
coreclr-testlist.txt
microbench-perf.sh
+3 -1
View File
@@ -3,9 +3,10 @@ BENCHMARKER_PATH=$(ACCEPTANCE_TESTS_PATH)/benchmarker
ROSLYN_PATH=$(ACCEPTANCE_TESTS_PATH)/roslyn
CORECLR_PATH=$(ACCEPTANCE_TESTS_PATH)/coreclr
MSTESTSUITE_PATH=$(ACCEPTANCE_TESTS_PATH)/ms-test-suite
DEBIANSHOOTOUTMONO_PATH=$(ACCEPTANCE_TESTS_PATH)/DebianShootoutMono
CLEANFILES = *.dll *.exe *.mdb
EXTRA_DIST=README.md SUBMODULES.json versions.mk profiler-stress.mk roslyn.mk coreclr.mk ms-test-suite.mk
EXTRA_DIST=README.md SUBMODULES.json microbench.mk versions.mk profiler-stress.mk roslyn.mk coreclr.mk ms-test-suite.mk
CLASS=$(mcs_topdir)/class/lib/$(DEFAULT_PROFILE)
TOOLS_CLASS=$(mcs_topdir)/class/lib/build
@@ -17,6 +18,7 @@ ILASM = $(TOOLS_RUNTIME) $(TOOLS_CLASS)/ilasm.exe
XUNIT = $(RUNTIME) $(abs_top_builddir)/external/xunit-binaries/xunit.console.exe
include versions.mk
include microbench.mk
include profiler-stress.mk
include roslyn.mk
include coreclr.mk
+10 -2
View File
@@ -10,7 +10,7 @@
{
"name": "coreclr",
"url": "git://github.com/mono/coreclr.git",
"rev": "f3d9c9f742f9dcb5faf40080db5e7f464dab7e7c",
"rev": "90f7060935732bb624e1f325d23f63072433725f",
"remote-branch": "origin/mono",
"branch": "mono",
"directory": "coreclr"
@@ -18,7 +18,7 @@
{
"name": "ms-test-suite",
"url": "[email protected]:xamarin/ms-test-suite.git",
"rev": "67f29dfc0741b5311dd746c75760963a2915e648",
"rev": "39b1b222e8a3690a1b8ea018ce54d2a826f5246e",
"remote-branch": "origin/master",
"branch": "master",
"directory": "ms-test-suite"
@@ -30,5 +30,13 @@
"remote-branch": "origin/master",
"branch": "master",
"directory": "benchmarker"
},
{
"name": "DebianShootoutMono",
"url": "https://github.com/alexanderkyte/DebianShootoutMono.git",
"rev": "3fde2ced806c1fe7eed81120a40d99474fa009f0",
"remote-branch": "origin/release_11_15_2018",
"branch": "release_11_15_2018",
"directory": "DebianShootoutMono"
}
]
-1
View File
@@ -3175,7 +3175,6 @@ CORECLR_COREMANGLIB_TEST_CS_SRC= \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/inattribute/inattributector.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/layoutkind/layoutkindauto.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/layoutkind/layoutkindsequential.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshal/marshalgetlastwin32error.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshal/marshalreadint641.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshal/marshalsizeof1.cs \
$(CORECLR_PATH)/tests/src/CoreMangLib/cti/system/runtime/interopservices/marshalasattribute/marshalasattributearraysubtype.cs \
+17
View File
@@ -0,0 +1,17 @@
#! /bin/sh
r='@mono_build_root@'
aotpattern="--aot="
# if this is an aot invoke
if [[ $@ =~ $aotpattern ]];
then
# just aot the code
echo "$r/runtime/mono-wrapper $@"
exec $r/runtime/mono-wrapper $@
else
# else run it under perf
echo "$MONO_PERF_BINARY record -o $r/acceptance-tests/perf.data -v -s -g -- $r/mono/mini/mono-sgen $@"
exec $MONO_PERF_BINARY record -o $r/acceptance-tests/perf.data -v -s -g $r/mono/mini/mono-sgen $@
fi
+119
View File
@@ -0,0 +1,119 @@
check-microbench: DebianShootoutMono.stamp
@$(MAKE) test-run-microbench
DebianShootoutMono.stamp:
@$(MAKE) validate-DebianShootoutMono RESET_VERSIONS=1
@$(MAKE) prepare-dlls
@touch $@
abs_top_srcdir = $(abspath $(top_srcdir))
TEST_EXE_PATH=$(abs_top_srcdir)/acceptance-tests/external/DebianShootoutMono/release/
NET_4_X_RUNTIME=MONO_PATH=$(TEST_EXE_PATH):$(abs_top_srcdir)/mcs/class/lib/net_4_x $(abs_top_srcdir)/runtime/mono-wrapper
FULL_AOT_RUNTIME=MONO_PATH=$(abs_top_srcdir)/mcs/class/lib/testing_aot_full $(abs_top_srcdir)/runtime/mono-wrapper
PERF_BINARY=$(if $(MONO_PERF_BINARY),$(MONO_PERF_BINARY),perf)
PERF_RUNTIME=$(abs_top_srcdir)/acceptance-tests/microbench-perf.sh
define BenchmarkDotNetTemplate
run-microbench-$(1):: DebianShootoutMono.stamp
MONO_BENCH_AOT_RUN="$(AOT_RUN_FLAGS)" \
MONO_BENCH_AOT_BUILD="$(AOT_BUILD_FLAGS)" \
MONO_BENCH_EXECUTABLE="$(abs_top_srcdir)/runtime/mono-wrapper" \
MONO_BENCH_PATH="$(abs_top_srcdir)/mcs/class/lib/$(TEST_PROFILE)" \
MONO_BENCH_INPUT="$(2)" \
$(NET_4_X_RUNTIME) \
$(TEST_EXE_PATH)/DebianShootoutMono.exe $(1)
test-run-microbench:: run-microbench-$(1)
run-microbench-debug-$(1):: DebianShootoutMono.stamp
echo MONO_PATH="$(abs_top_srcdir)/mcs/class/lib/$(TEST_PROFILE)" $(abs_top_srcdir)/runtime/mono-wrapper $(AOT_BUILD_FLAGS) $(TEST_EXE_PATH)/DebianShootoutMono.exe
MONO_BENCH_INPUT="$(2)" \
MONO_PATH="$(abs_top_srcdir)/mcs/class/lib/$(TEST_PROFILE)" \
$(abs_top_srcdir)/runtime/mono-wrapper $(AOT_RUN_FLAGS) $(TEST_EXE_PATH)/DebianShootoutMono.exe Run $(1)
test-run-microbench-debug:: run-microbench-debug-$(1)
if HOST_LINUX
run-microbench-profiled-$(1):: microbench-results/$(1).perf.data
microbench-results/$(1).perf.data: DebianShootoutMono.stamp
mkdir -p microbench-results
MONO_PERF_BINARY="$(PERF_BINARY)" \
MONO_BENCH_EXECUTABLE="$(PERF_RUNTIME)" \
MONO_BENCH_AOT_RUN="$(AOT_RUN_FLAGS)"\
MONO_BENCH_AOT_BUILD="$(AOT_BUILD_FLAGS)"\
MONO_BENCH_PATH="$(abs_top_srcdir)/mcs/class/lib/$(TEST_PROFILE)" \
MONO_BENCH_INPUT="$(2)" \
$(NET_4_X_RUNTIME) \
$(TEST_EXE_PATH)/DebianShootoutMono.exe $(1) $(2)
mv perf.data microbench-results/$(1).perf.data
microbench-results/$(1).tmp.perf: microbench-results/$(1).perf.data
$(PERF_BINARY) script -i microbench-results/$(1).perf.data > microbench-results/$(1).tmp.perf
microbench-results/$(1).perf-flame.svg: microbench-results/$(1).tmp.perf
cat microbench-results/$(1).tmp.perf | ./external/DebianShootoutMono/FlameGraph/stackcollapse-perf.pl > microbench-results/$(1).perf-folded
./external/DebianShootoutMono/FlameGraph/flamegraph.pl microbench-results/$(1).perf-folded > microbench-results/$(1).perf-flame.svg
rm microbench-results/$(1).tmp.perf
rm microbench-results/$(1).perf-folded
MONO_PERF_FLAGS=--show-cpu-utilization -n --hierarchy -T $(MONO_PERF_ADDITIONAL_FLAGS)
microbench-results/$(1).perf.report: microbench-results/$(1).perf.data
$(PERF_BINARY) report -i microbench-results/$(1).perf.data $(MONO_PERF_FLAGS) > microbench-results/$(1).perf.report
test-run-microbench-profiled:: run-microbench-profiled-$(1)
test-run-microbench-publish-collect:: microbench-results/$(1).perf.data microbench-results/$(1).perf.report microbench-results/$(1).perf-flame.svg
endif
endef
if HOST_LINUX
test-run-microbench-perf-check:
$(PERF_BINARY) record -a -o perf.data -- echo "testing"
rm perf.data
microbench-results/perf-data.zip:
zip microbench-results/perf-data.zip microbench-results/*.perf.data
rm microbench-results/*.perf.data
perf-report: microbench-results/perf-data.zip
perf-report-total: test-run-microbench-publish-collect
@$(MAKE) perf-report
endif
.PHONY: prepare-dlls
if FULL_AOT_TESTS
prepare-dlls:
$(FULL_AOT_RUNTIME) $(AOT_BUILD_FLAGS) $(TEST_EXE_PATH)/*.{dll,exe}
else
prepare-dlls:
endif
FIXTURE_DIR=$(abs_top_srcdir)/acceptance-tests/external/DebianShootoutMono/fixtures
$(eval $(call BenchmarkDotNetTemplate,Mandelbrot,))
$(eval $(call BenchmarkDotNetTemplate,RegexRedux,$(FIXTURE_DIR)/regexredux-input.txt))
$(eval $(call BenchmarkDotNetTemplate,KNucleotide,$(FIXTURE_DIR)/knucleotide-input.txt))
$(eval $(call BenchmarkDotNetTemplate,BinaryTrees,))
$(eval $(call BenchmarkDotNetTemplate,NBodyTest,))
$(eval $(call BenchmarkDotNetTemplate,SpectralNorm,))
$(eval $(call BenchmarkDotNetTemplate,Fannkuchredux,))
$(eval $(call BenchmarkDotNetTemplate,Fasta,))
$(eval $(call BenchmarkDotNetTemplate,RevComp,$(FIXTURE_DIR)/revcomp-input.txt))
#$(eval $(call BenchmarkDotNetTemplate,GistBenchmark,$(MONO_BENCH_GIST_URL))) broken in BDN, bug filed
+2
View File
@@ -1,4 +1,6 @@
check-roslyn:
@echo "Runnning roslyn tests using mono from PATH:"
mono --version
@$(MAKE) validate-roslyn RESET_VERSIONS=1
cd $(ROSLYN_PATH); \
./build.sh --restore --build --test --mono || exit; \
+10
View File
@@ -7,6 +7,7 @@ $(eval $(call ValidateVersionTemplate,benchmarker,BENCHMARKER))
$(eval $(call ValidateVersionTemplate,roslyn,ROSLYN))
$(eval $(call ValidateVersionTemplate,coreclr,CORECLR))
$(eval $(call ValidateVersionTemplate,ms-test-suite,MSTESTSUITE))
$(eval $(call ValidateVersionTemplate,DebianShootoutMono,DEBIANSHOOTOUTMONO))
# Bump the given submodule to the revision given by the REV make variable
# If COMMIT is 1, commit the change
@@ -14,6 +15,7 @@ bump-benchmarker: __bump-benchmarker
bump-roslyn: __bump-version-roslyn
bump-coreclr: __bump-version-coreclr
bump-ms-test-suite: __bump-version-ms-test-suite
bump-DebianShootoutMono: __bump-version-DebianShootoutMono
# Bump the given submodule to the branch given by the BRANCH/REMOTE_BRANCH make variables
# If COMMIT is 1, commit the change
@@ -21,6 +23,7 @@ bump-branch-benchmarker: __bump-branch-benchmarker
bump-branch-roslyn: __bump-branch-roslyn
bump-branch-coreclr: __bump-branch-coreclr
bump-branch-ms-test-suite: __bump-branch-ms-test-suite
bump-branch-DebianShootoutMono: __bump-branch-DebianShootoutMono
# Bump the given submodule to its current GIT version
# If COMMIT is 1, commit the change
@@ -28,6 +31,7 @@ bump-current-benchmarker: __bump-current-benchmarker
bump-current-roslyn: __bump-current-version-roslyn
bump-current-coreclr: __bump-current-version-coreclr
bump-current-ms-test-suite: __bump-current-version-ms-test-suite
bump-current-DebianShootoutMono: __bump-current-version-DebianShootoutMono
commit-bump-benchmarker:
$(MAKE) bump-benchmarker COMMIT=1
@@ -41,6 +45,9 @@ commit-bump-coreclr:
commit-bump-ms-test-suite:
$(MAKE) bump-ms-test-suite COMMIT=1
commit-bump-DebianShootoutMono:
$(MAKE) bump-DebianShootoutMono COMMIT=1
commit-bump-current-benchmarker:
$(MAKE) bump-current-benchmarker COMMIT=1
@@ -52,3 +59,6 @@ commit-bump-current-coreclr:
commit-bump-current-ms-test-suite:
$(MAKE) bump-current-ms-test-suite COMMIT=1
commit-bump-current-DebianShootoutMono:
$(MAKE) bump-current-DebianShootoutMono COMMIT=1
+1 -1
View File
@@ -120,7 +120,7 @@ for PARAM; do
done
if test x$has_ext_mod = xtrue; then
pushd ../mono-extensions/scripts
pushd $top_srcdir../mono-extensions/scripts
sh ./prepare-repo.sh $ext_mod_args || exit 1
popd
else
+121 -343
View File
@@ -1,6 +1,6 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
MinimumVisualStudioVersion = 15.0.0.0
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "jay", "mcs/jay/jay.vcxproj", "{5d485d32-3b9f-4287-ab24-c8da5b89f537}"
EndProject
@@ -188,7 +188,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Cecil.Mdb", "mcs/class
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.CSharp", "mcs/class/Mono.CSharp/Mono.CSharp.csproj", "{817CE046-07E8-409D-84BF-A6EA4F2879DE}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Debugger.Soft", "mcs/class/Mono.Debugger.Soft/Mono.Debugger.Soft.csproj", "{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}"
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Debugger.Soft", "mcs/class/Mono.Debugger.Soft/Mono.Debugger.Soft.csproj", "{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.C5", "mcs/class/Mono.C5/Mono.C5.csproj", "{A9F5A575-3725-4691-A7A6-0ABDEA3994CE}"
EndProject
@@ -302,10 +302,6 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Build.Tasks", "mc
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Build", "mcs/class/Microsoft.Build/Microsoft.Build.csproj", "{86E2C258-C0D8-48D0-BA76-0280A981CEE0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Drawing.Primitives", "mcs/class/Facades/System.Drawing.Primitives/Facades_System.Drawing.Primitives.csproj", "{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_netstandard", "mcs/class/Facades/netstandard/Facades_netstandard.csproj", "{E4596A34-AFBC-4744-8352-E6996AC34C16}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Collections.Concurrent", "mcs/class/Facades/System.Collections.Concurrent/Facades_System.Collections.Concurrent.csproj", "{DE0D7286-1F09-4ACC-BC43-75342349FFC1}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Collections", "mcs/class/Facades/System.Collections/Facades_System.Collections.csproj", "{758C73D3-F04B-40BD-B55B-057F529053CA}"
@@ -568,26 +564,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Runtime.Seri
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Security.Cryptography.Algorithms", "mcs/class/Facades/System.Security.Cryptography.Algorithms/Facades_System.Security.Cryptography.Algorithms.csproj", "{942F9B7C-3245-4F5A-A4ED-140013DCCE2C}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_netstandard", "mcs/class/Facades/netstandard/Facades_netstandard.csproj", "{E4596A34-AFBC-4744-8352-E6996AC34C16}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Drawing.Primitives", "mcs/class/Facades/System.Drawing.Primitives/Facades_System.Drawing.Primitives.csproj", "{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Facades_System.Net.Http.Rtc", "mcs/class/Facades/System.Net.Http.Rtc/Facades_System.Net.Http.Rtc.csproj", "{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NUnit.Framework", "mcs/nunit24/NUnitFramework/framework/NUnit.Framework.csproj", "{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core.interfaces", "mcs/nunit24/NUnitCore/interfaces/nunit.core.interfaces.csproj", "{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core", "mcs/nunit24/NUnitCore/core/nunit.core.csproj", "{559F5BCC-3235-494A-9D86-4F26F67F9E40}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.util", "mcs/nunit24/ClientUtilities/util/nunit.util.csproj", "{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.mocks", "mcs/nunit24/NUnitMocks/mocks/nunit.mocks.csproj", "{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.framework.extensions", "mcs/nunit24/NUnitExtensions/framework/nunit.framework.extensions.csproj", "{DFE253AA-843E-4374-B862-9F0B7414CB8C}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit.core.extensions", "mcs/nunit24/NUnitExtensions/core/nunit.core.extensions.csproj", "{6464D30A-2B8E-458D-B96A-2ECDE947B58B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit-console-runner", "mcs/nunit24/ConsoleRunner/nunit-console/nunit-console-runner.csproj", "{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "nunit-console", "mcs/nunit24/ConsoleRunner/nunit-console-exe/nunit-console.csproj", "{2D845BF5-42C7-41D3-AC01-F63980F76B22}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ilasm", "mcs/ilasm/ilasm.csproj", "{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "al", "mcs/tools/al/al.csproj", "{0A20671F-CCA9-457D-886C-0828C7D64128}"
@@ -1126,22 +1108,14 @@ Global
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|orbis.ActiveCfg = Debug|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|orbis.Build.0 = Debug|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|orbis.ActiveCfg = Release|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|orbis.Build.0 = Release|orbis
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|unreal.ActiveCfg = Debug|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|unreal.Build.0 = Debug|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|unreal.ActiveCfg = Release|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|unreal.Build.0 = Release|unreal
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|wasm.ActiveCfg = Debug|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|wasm.Build.0 = Debug|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|wasm.ActiveCfg = Release|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|wasm.Build.0 = Release|wasm
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|winaot.ActiveCfg = Debug|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|winaot.Build.0 = Debug|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|winaot.ActiveCfg = Release|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|winaot.Build.0 = Release|winaot
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|orbis.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|orbis.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|unreal.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|unreal.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|wasm.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|wasm.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|winaot.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|winaot.ActiveCfg = Release|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Debug|xammac.ActiveCfg = Debug|net_4_x
{DCB27742-5382-4CB3-B7D8-A6DF92B8B68C}.Release|xammac.ActiveCfg = Release|net_4_x
{4900DA48-CB1B-4520-98EE-F6B0F3054341}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
@@ -3370,28 +3344,28 @@ Global
{817CE046-07E8-409D-84BF-A6EA4F2879DE}.Debug|xammac.Build.0 = Debug|xammac
{817CE046-07E8-409D-84BF-A6EA4F2879DE}.Release|xammac.ActiveCfg = Release|xammac
{817CE046-07E8-409D-84BF-A6EA4F2879DE}.Release|xammac.Build.0 = Release|xammac
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|net_4_x.Build.0 = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|net_4_x.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|net_4_x.Build.0 = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|monodroid.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|monotouch.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|orbis.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|orbis.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|unreal.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|unreal.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|wasm.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|wasm.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|winaot.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|winaot.ActiveCfg = Release|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Debug|xammac.ActiveCfg = Debug|net_4_x
{8787A3B7-8A19-4586-8DCF-6F5914FD48D5}.Release|xammac.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|net_4_x.Build.0 = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|net_4_x.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|net_4_x.Build.0 = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|monodroid.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|monotouch.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|orbis.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|orbis.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|unreal.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|unreal.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|wasm.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|wasm.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|winaot.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|winaot.ActiveCfg = Release|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Debug|xammac.ActiveCfg = Debug|net_4_x
{767CAD15-F8B5-4EAC-8B3D-4EF75F768015}.Release|xammac.ActiveCfg = Release|net_4_x
{A9F5A575-3725-4691-A7A6-0ABDEA3994CE}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{A9F5A575-3725-4691-A7A6-0ABDEA3994CE}.Debug|net_4_x.Build.0 = Debug|net_4_x
{A9F5A575-3725-4691-A7A6-0ABDEA3994CE}.Release|net_4_x.ActiveCfg = Release|net_4_x
@@ -3482,8 +3456,10 @@ Global
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|unreal.ActiveCfg = Release|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|wasm.ActiveCfg = Debug|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|wasm.ActiveCfg = Release|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|winaot.ActiveCfg = Debug|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|winaot.ActiveCfg = Release|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|winaot.ActiveCfg = Debug|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|winaot.Build.0 = Debug|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|winaot.ActiveCfg = Release|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|winaot.Build.0 = Release|winaot
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Debug|xammac.ActiveCfg = Debug|net_4_x
{045A3571-9B4B-4318-BD72-22C6CCD094F1}.Release|xammac.ActiveCfg = Release|net_4_x
{1B87A378-65E8-4899-9C9A-C940429D643C}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
@@ -4772,86 +4748,6 @@ Global
{86E2C258-C0D8-48D0-BA76-0280A981CEE0}.Release|winaot.ActiveCfg = Release|net_4_x
{86E2C258-C0D8-48D0-BA76-0280A981CEE0}.Debug|xammac.ActiveCfg = Debug|net_4_x
{86E2C258-C0D8-48D0-BA76-0280A981CEE0}.Release|xammac.ActiveCfg = Release|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|net_4_x.Build.0 = Debug|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|net_4_x.ActiveCfg = Release|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|net_4_x.Build.0 = Release|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monodroid.ActiveCfg = Debug|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monodroid.Build.0 = Debug|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monodroid.ActiveCfg = Release|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monodroid.Build.0 = Release|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch.ActiveCfg = Debug|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch.Build.0 = Debug|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch.ActiveCfg = Release|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch.Build.0 = Release|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_tv.ActiveCfg = Debug|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_tv.Build.0 = Debug|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_tv.ActiveCfg = Release|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_tv.Build.0 = Release|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_watch.ActiveCfg = Debug|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_watch.Build.0 = Debug|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_watch.ActiveCfg = Release|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_watch.Build.0 = Release|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|orbis.ActiveCfg = Debug|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|orbis.Build.0 = Debug|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|orbis.ActiveCfg = Release|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|orbis.Build.0 = Release|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|unreal.ActiveCfg = Debug|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|unreal.Build.0 = Debug|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|unreal.ActiveCfg = Release|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|unreal.Build.0 = Release|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|wasm.ActiveCfg = Debug|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|wasm.Build.0 = Debug|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|wasm.ActiveCfg = Release|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|wasm.Build.0 = Release|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|winaot.ActiveCfg = Debug|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|winaot.Build.0 = Debug|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|winaot.ActiveCfg = Release|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|winaot.Build.0 = Release|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|xammac.ActiveCfg = Debug|xammac
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|xammac.Build.0 = Debug|xammac
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|xammac.ActiveCfg = Release|xammac
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|xammac.Build.0 = Release|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|net_4_x.Build.0 = Debug|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|net_4_x.ActiveCfg = Release|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|net_4_x.Build.0 = Release|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monodroid.ActiveCfg = Debug|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monodroid.Build.0 = Debug|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monodroid.ActiveCfg = Release|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monodroid.Build.0 = Release|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch.ActiveCfg = Debug|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch.Build.0 = Debug|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch.ActiveCfg = Release|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch.Build.0 = Release|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_tv.ActiveCfg = Debug|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_tv.Build.0 = Debug|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_tv.ActiveCfg = Release|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_tv.Build.0 = Release|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_watch.ActiveCfg = Debug|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_watch.Build.0 = Debug|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_watch.ActiveCfg = Release|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_watch.Build.0 = Release|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|orbis.ActiveCfg = Debug|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|orbis.Build.0 = Debug|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|orbis.ActiveCfg = Release|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|orbis.Build.0 = Release|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|unreal.ActiveCfg = Debug|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|unreal.Build.0 = Debug|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|unreal.ActiveCfg = Release|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|unreal.Build.0 = Release|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|wasm.ActiveCfg = Debug|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|wasm.Build.0 = Debug|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|wasm.ActiveCfg = Release|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|wasm.Build.0 = Release|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|winaot.ActiveCfg = Debug|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|winaot.Build.0 = Debug|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|winaot.ActiveCfg = Release|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|winaot.Build.0 = Release|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|xammac.ActiveCfg = Debug|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|xammac.Build.0 = Debug|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|xammac.ActiveCfg = Release|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|xammac.Build.0 = Release|xammac
{DE0D7286-1F09-4ACC-BC43-75342349FFC1}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{DE0D7286-1F09-4ACC-BC43-75342349FFC1}.Debug|net_4_x.Build.0 = Debug|net_4_x
{DE0D7286-1F09-4ACC-BC43-75342349FFC1}.Release|net_4_x.ActiveCfg = Release|net_4_x
@@ -10092,6 +9988,86 @@ Global
{942F9B7C-3245-4F5A-A4ED-140013DCCE2C}.Debug|xammac.Build.0 = Debug|xammac
{942F9B7C-3245-4F5A-A4ED-140013DCCE2C}.Release|xammac.ActiveCfg = Release|xammac
{942F9B7C-3245-4F5A-A4ED-140013DCCE2C}.Release|xammac.Build.0 = Release|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|net_4_x.Build.0 = Debug|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|net_4_x.ActiveCfg = Release|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|net_4_x.Build.0 = Release|net_4_x
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monodroid.ActiveCfg = Debug|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monodroid.Build.0 = Debug|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monodroid.ActiveCfg = Release|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monodroid.Build.0 = Release|monodroid
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch.ActiveCfg = Debug|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch.Build.0 = Debug|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch.ActiveCfg = Release|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch.Build.0 = Release|monotouch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_tv.ActiveCfg = Debug|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_tv.Build.0 = Debug|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_tv.ActiveCfg = Release|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_tv.Build.0 = Release|monotouch_tv
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_watch.ActiveCfg = Debug|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|monotouch_watch.Build.0 = Debug|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_watch.ActiveCfg = Release|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|monotouch_watch.Build.0 = Release|monotouch_watch
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|orbis.ActiveCfg = Debug|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|orbis.Build.0 = Debug|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|orbis.ActiveCfg = Release|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|orbis.Build.0 = Release|orbis
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|unreal.ActiveCfg = Debug|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|unreal.Build.0 = Debug|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|unreal.ActiveCfg = Release|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|unreal.Build.0 = Release|unreal
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|wasm.ActiveCfg = Debug|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|wasm.Build.0 = Debug|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|wasm.ActiveCfg = Release|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|wasm.Build.0 = Release|wasm
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|winaot.ActiveCfg = Debug|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|winaot.Build.0 = Debug|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|winaot.ActiveCfg = Release|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|winaot.Build.0 = Release|winaot
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|xammac.ActiveCfg = Debug|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Debug|xammac.Build.0 = Debug|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|xammac.ActiveCfg = Release|xammac
{E4596A34-AFBC-4744-8352-E6996AC34C16}.Release|xammac.Build.0 = Release|xammac
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|net_4_x.Build.0 = Debug|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|net_4_x.ActiveCfg = Release|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|net_4_x.Build.0 = Release|net_4_x
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monodroid.ActiveCfg = Debug|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monodroid.Build.0 = Debug|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monodroid.ActiveCfg = Release|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monodroid.Build.0 = Release|monodroid
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch.ActiveCfg = Debug|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch.Build.0 = Debug|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch.ActiveCfg = Release|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch.Build.0 = Release|monotouch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_tv.ActiveCfg = Debug|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_tv.Build.0 = Debug|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_tv.ActiveCfg = Release|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_tv.Build.0 = Release|monotouch_tv
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_watch.ActiveCfg = Debug|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|monotouch_watch.Build.0 = Debug|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_watch.ActiveCfg = Release|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|monotouch_watch.Build.0 = Release|monotouch_watch
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|orbis.ActiveCfg = Debug|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|orbis.Build.0 = Debug|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|orbis.ActiveCfg = Release|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|orbis.Build.0 = Release|orbis
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|unreal.ActiveCfg = Debug|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|unreal.Build.0 = Debug|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|unreal.ActiveCfg = Release|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|unreal.Build.0 = Release|unreal
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|wasm.ActiveCfg = Debug|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|wasm.Build.0 = Debug|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|wasm.ActiveCfg = Release|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|wasm.Build.0 = Release|wasm
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|winaot.ActiveCfg = Debug|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|winaot.Build.0 = Debug|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|winaot.ActiveCfg = Release|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|winaot.Build.0 = Release|winaot
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|xammac.ActiveCfg = Debug|xammac
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Debug|xammac.Build.0 = Debug|xammac
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|xammac.ActiveCfg = Release|xammac
{1961C6D4-5B4D-4D82-A9AF-C6134D346B63}.Release|xammac.Build.0 = Release|xammac
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Debug|net_4_x.Build.0 = Debug|net_4_x
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Release|net_4_x.ActiveCfg = Release|net_4_x
@@ -10114,204 +10090,6 @@ Global
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Release|winaot.ActiveCfg = Release|net_4_x
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Debug|xammac.ActiveCfg = Debug|net_4_x
{786AAD60-DBEA-4F9B-BF1B-C3486CE000D0}.Release|xammac.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|net_4_x.Build.0 = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|net_4_x.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|net_4_x.Build.0 = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monodroid.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monotouch.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|orbis.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|orbis.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|unreal.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|unreal.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|wasm.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|wasm.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|winaot.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|winaot.ActiveCfg = Release|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Debug|xammac.ActiveCfg = Debug|net_4_x
{5A1007E5-0FDA-42F5-98AC-D61E11C4B3AB}.Release|xammac.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|net_4_x.Build.0 = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|net_4_x.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|net_4_x.Build.0 = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monodroid.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monotouch.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|orbis.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|orbis.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|unreal.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|unreal.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|wasm.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|wasm.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|winaot.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|winaot.ActiveCfg = Release|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Debug|xammac.ActiveCfg = Debug|net_4_x
{9B6CBD42-1AA3-40FA-A8B3-80C63EA47A02}.Release|xammac.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|net_4_x.Build.0 = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|net_4_x.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|net_4_x.Build.0 = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monodroid.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monotouch.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|orbis.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|orbis.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|unreal.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|unreal.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|wasm.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|wasm.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|winaot.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|winaot.ActiveCfg = Release|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Debug|xammac.ActiveCfg = Debug|net_4_x
{559F5BCC-3235-494A-9D86-4F26F67F9E40}.Release|xammac.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|net_4_x.Build.0 = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|net_4_x.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|net_4_x.Build.0 = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monodroid.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monotouch.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|orbis.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|orbis.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|unreal.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|unreal.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|wasm.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|wasm.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|winaot.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|winaot.ActiveCfg = Release|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Debug|xammac.ActiveCfg = Debug|net_4_x
{8F75DF82-CC9B-44A0-97CC-8ED180AFF6EF}.Release|xammac.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|net_4_x.Build.0 = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|net_4_x.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|net_4_x.Build.0 = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monodroid.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monotouch.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|orbis.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|orbis.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|unreal.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|unreal.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|wasm.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|wasm.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|winaot.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|winaot.ActiveCfg = Release|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Debug|xammac.ActiveCfg = Debug|net_4_x
{94A88112-9E7E-45FA-A3FF-ACF8E1DF0FCB}.Release|xammac.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|net_4_x.Build.0 = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|net_4_x.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|net_4_x.Build.0 = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monodroid.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monotouch.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|orbis.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|orbis.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|unreal.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|unreal.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|wasm.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|wasm.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|winaot.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|winaot.ActiveCfg = Release|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Debug|xammac.ActiveCfg = Debug|net_4_x
{DFE253AA-843E-4374-B862-9F0B7414CB8C}.Release|xammac.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|net_4_x.Build.0 = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|net_4_x.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|net_4_x.Build.0 = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monodroid.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monotouch.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|orbis.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|orbis.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|unreal.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|unreal.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|wasm.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|wasm.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|winaot.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|winaot.ActiveCfg = Release|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Debug|xammac.ActiveCfg = Debug|net_4_x
{6464D30A-2B8E-458D-B96A-2ECDE947B58B}.Release|xammac.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|net_4_x.Build.0 = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|net_4_x.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|net_4_x.Build.0 = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monodroid.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monotouch.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|orbis.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|orbis.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|unreal.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|unreal.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|wasm.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|wasm.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|winaot.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|winaot.ActiveCfg = Release|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Debug|xammac.ActiveCfg = Debug|net_4_x
{F0B8A9C7-8D0D-4629-B730-CFCB17C4BB2D}.Release|xammac.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|net_4_x.Build.0 = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|net_4_x.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|net_4_x.Build.0 = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monodroid.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monodroid.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monotouch.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monotouch.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monotouch_tv.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monotouch_tv.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|monotouch_watch.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|monotouch_watch.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|orbis.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|orbis.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|unreal.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|unreal.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|wasm.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|wasm.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|winaot.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|winaot.ActiveCfg = Release|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Debug|xammac.ActiveCfg = Debug|net_4_x
{2D845BF5-42C7-41D3-AC01-F63980F76B22}.Release|xammac.ActiveCfg = Release|net_4_x
{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}.Debug|net_4_x.ActiveCfg = Debug|net_4_x
{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}.Debug|net_4_x.Build.0 = Debug|net_4_x
{C02B3C37-DB98-40A5-84F0-F98633DA7EE4}.Release|net_4_x.ActiveCfg = Release|net_4_x
+745 -135
View File
File diff suppressed because it is too large. Load diff
+3 -3
View File
@@ -7,7 +7,7 @@ EXTRA_DIST = \
config.in \
browscap.ini mono.supp mono.d README \
mono.pc.in mono-2.pc.in monosgen-2.pc.in mint.pc.in dotnet.pc.in dotnet35.pc.in wcf.pc.in monodoc.pc.in \
mono-nunit.pc.in mono-cairo.pc.in mono-options.pc.in cecil.pc.in \
mono-cairo.pc.in mono-options.pc.in cecil.pc.in \
mono-lineeditor.pc.in system.web.extensions_1.0.pc.in system.web.extensions.design_1.0.pc.in\
dtrace-prelink.sh system.web.mvc.pc.in system.web.mvc2.pc.in system.web.mvc3.pc.in aspnetwebstack.pc.in \
reactive.pc.in xbuild12.pc \
@@ -25,10 +25,10 @@ else
SGENPCFILE=
endif
pkgconfig_DATA= mono.pc mono-2.pc dotnet.pc dotnet35.pc wcf.pc mono-nunit.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
pkgconfig_DATA= mono.pc mono-2.pc dotnet.pc dotnet35.pc wcf.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
system.web.extensions.design_1.0.pc system.web.mvc.pc system.web.mvc2.pc system.web.mvc3.pc aspnetwebstack.pc reactive.pc xbuild12.pc $(SGENPCFILE)
DISTCLEANFILES= mono-2.pc mono.pc mint.pc dotnet.pc dotnet35.pc wcf.pc mono-nunit.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
DISTCLEANFILES= mono-2.pc mono.pc mint.pc dotnet.pc dotnet35.pc wcf.pc mono-cairo.pc mono-options.pc cecil.pc monodoc.pc mono-lineeditor.pc system.web.extensions_1.0.pc \
system.web.extensions.design_1.0.pc system.web.mvc.pc system.web.mvc2.pc system.web.mvc3.pc aspnetwebstack.pc reactive.pc $(SGENPCFILE) mono-sgen-gdb.py
mono_DATA = config \
Regular → Executable
View File
File mode changed.
+1 -1
View File
@@ -20,7 +20,7 @@ def print_frames(thread, num_frames, current_thread):
ipoffset = frame.EvaluateExpression('ip').GetValueAsUnsigned()
insn = ''
if ipoffset != 0:
ipoffset -= frame.EvaluateExpression('rtm->code').GetValueAsUnsigned()
ipoffset -= frame.EvaluateExpression('imethod->code').GetValueAsUnsigned()
insn = "\"" + frame.EvaluateExpression('mono_interp_opname [*ip]').summary[1:-1] + "\""
var = '%s::%s @ %d %s || %s' % (klassname, methodname, ipoffset, insn, frame)
except Exception as e:
-9
View File
@@ -1,9 +0,0 @@
prefix=${pcfiledir}/../..
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
Name: Mono NUnit
Description: Mono's version of NUnit
Version: @VERSION@
Libs: -r:${libdir}/mono/4.5/nunit.core.dll -r:${libdir}/mono/4.5/nunit.core.interfaces.dll -r:${libdir}/mono/4.5/nunit.core.extensions.dll -r:${libdir}/mono/4.5/nunit.framework.dll -r:${libdir}/mono/4.5/nunit.framework.extensions.dll -r:${libdir}/mono/4.5/nunit.mocks.dll -r:${libdir}/mono/4.5/nunit.util.dll -r:${libdir}/mono/4.5/nunit-console-runner.dll
+3 -2
View File
@@ -52,7 +52,8 @@ EXTRA_DIST = \
-include $(mcs_topdir)/build/config.make
CLASS=$(mcs_topdir)/class/lib/$(DEFAULT_PROFILE)
DOC_PROFILE:=net_4_x
CLASS=$(mcs_topdir)/class/lib/$(DOC_PROFILE)
dist-hook:
$(mkdir_p) $(distdir)/sources
@@ -68,7 +69,7 @@ clean-local:
-rm -f deploy/* convert.exe* AgilityPack.dll*
-rm -f $(ASSEMBLED_DOCS)
TOOL_MAKE=$(MAKE) -f $(srcdir)/docs.make topdir=$(srcdir)/../mcs srcdir=$(srcdir)
TOOL_MAKE=$(MAKE) -f $(srcdir)/docs.make topdir=$(srcdir)/../mcs srcdir=$(srcdir) PROFILE=$(DOC_PROFILE)
monoapi.zip: monoapi.tree
+116
View File
@@ -0,0 +1,116 @@
# Mono RISC-V Port
These are some useful links and notes pertaining to the RISC-V port of Mono.
## Useful RISC-V documents
* [RISC-V User-Level ISA Specification](https://riscv.org/specifications/)
* [RISC-V Privileged ISA Specification](https://riscv.org/specifications/privileged-isa/)
* [RISC-V Debug Specification Standard](https://github.com/riscv/riscv-debug-spec/blob/master/riscv-debug-spec.pdf)
* [RISC-V Assembly Programmer's Manual](https://github.com/riscv/riscv-asm-manual/blob/master/riscv-asm.md)
* [RISC-V ELF psABI Specification](https://github.com/riscv/riscv-elf-psabi-doc/blob/master/riscv-elf.md)
## Useful RISC-V repositories
* [RISC-V Organization](https://github.com/riscv)
* [RISC-V Linux](https://github.com/riscv/riscv-linux)
* [RISC-V LLD](https://github.com/riscv/riscv-lld)
* [RISC-V Tools](https://github.com/riscv/riscv-tools)
* [RISC-V GNU Toolchain](https://github.com/riscv/riscv-gnu-toolchain)
* [RISC-V Binutils](https://github.com/riscv/riscv-binutils-gdb)
* [RISC-V GCC](https://github.com/riscv/riscv-gcc)
* [RISC-V Glibc](https://github.com/riscv/riscv-glibc)
* [RISC-V Newlib](https://github.com/riscv/riscv-newlib)
* [RISC-V QEMU](https://github.com/riscv/riscv-qemu)
* [RISC-V Opcodes](https://github.com/riscv/riscv-opcodes)
* [RISC-V Tests](https://github.com/riscv/riscv-tests)
* [lowRISC Organization](https://github.com/lowrisc)
* [RISC-V LLVM](https://github.com/lowrisc/riscv-llvm)
## Setting up a cross environment
Setting up a cross environment with a Linux toolchain and QEMU is quite easy.
First, add these to your `.bashrc` (or some other script that you run):
```bash
export RISCV=$HOME/riscv
export PATH=$RISCV/bin:$PATH
export QEMU_LD_PREFIX=$RISCV/sysroot
```
Install some dependencies needed to build the toolchain:
```console
# apt install autoconf automake autotools-dev curl libmpc-dev libmpfr-dev libgmp-dev libusb-1.0-0-dev gawk build-essential bison flex texinfo gperf libtool patchutils bc zlib1g-dev device-tree-compiler pkg-config libexpat-dev libglib2.0-dev libpixman-1-dev
```
Now you can build the toolchain:
```console
$ git clone --recursive [email protected]:riscv/riscv-tools.git
$ cd riscv-tools
$ ./build.sh
$ cd riscv-gnu-toolchain
$ ./configure --prefix=$RISCV --enable-multilib
$ make linux
$ cd ../..
$ git clone --recursive [email protected]:riscv/riscv-qemu.git
$ cd riscv-qemu
$ mkdir build
$ cd build
$ ../configure --prefix=$RISCV --disable-werror
$ make
$ make install
```
## Building Mono with a cross toolchain
Building Mono is quite straightforward:
```console
$ ./autogen.sh --prefix=$RISCV/sysroot --host=riscv64-unknown-linux-gnu
$ make
$ make install
```
You can set `CFLAGS` as appropriate to change the RISC-V options, such as which
standard extensions and ABI to use. For example, to use the 64-bit soft float
ABI:
```console
$ CFLAGS="-mabi=lp64" ./autogen.sh --prefix=$RISCV/sysroot --host=riscv64-unknown-linux-gnu
```
Note that, since this is a cross build, the `mcs` directory won't be built. You
will have to build the managed libraries and tools through a native build of
Mono and copy them into `$RISCV/sysroot`.
You can run Mono with QEMU like this:
```console
$ qemu-riscv64 $RISCV/sysroot/bin/mono hello.exe
```
## Debugging
```console
$ qemu-riscv64 -g 12345 ./mono/mini/mono-sgen --interp basic.exe &
$ riscv64-unknown-elf-gdb -ex 'target remote localhost:12345' -ex 'b main' -ex 'c' ./mono/mini/mono-sgen
```
## Things to be done
In no particular order:
* Complete the soft float port.
* Complete the 32-bit port.
* Add unwind info to trampolines.
* Implement AOT support.
* Implement interpreter support.
* Implement LLVM support.
* Implement SDB support.
* Implement `dyn_call` support.
* Ensure all runtime tests pass.
* Ensure all corlib tests pass.
* Set up CI on Jenkins.
+1 -1
+1 -1
+1 -1
Vendored Submodule
+1
Submodule external/helix-binaries added at 64b3a67631.
+1 -1
+1 -1
Vendored Submodule
+1
Submodule external/llvm added at 286f431858.
+3
View File
@@ -185,3 +185,6 @@ EXTRA_DIST += configure.host
.S.s:
if $(CPP) $< >$@ ; then :; else rm -f $@; fi
test:
test-bundle:
+8 -2
View File
@@ -5,6 +5,14 @@
#define GC_PTHREAD_REDIRECTS_H
#ifdef __cplusplus
extern "C" {
#endif
void * GC_dlopen(const char *path, int mode);
#ifdef __cplusplus
} // extern "C"
#endif
#if defined(GC_SOLARIS_THREADS)
/* We need to intercept calls to many of the threads primitives, so */
/* that we can locate thread stacks and stop the world. */
@@ -26,7 +34,6 @@ extern "C" {
int GC_thr_join(thread_t wait_for, thread_t *departed, void **status);
int GC_thr_suspend(thread_t target_thread);
int GC_thr_continue(thread_t target_thread);
void * GC_dlopen(const char *path, int mode);
# define thr_create GC_thr_create
# define thr_join GC_thr_join
# define thr_suspend GC_thr_suspend
@@ -66,7 +73,6 @@ extern "C" {
# define dlopen GC_dlopen
#endif /* SOLARIS_THREADS || SOLARIS_PTHREADS */
#if !defined(GC_USE_LD_WRAP) && (defined(GC_PTHREADS) || defined(GC_DARWIN_THREADS) || defined(GC_MACOSX_THREADS)) && !defined(GC_SOLARIS_PTHREADS)
/* We treat these similarly. */
# include <pthread.h>
+7 -3
View File
@@ -1,5 +1,5 @@
EXTRA_DIST=SUBMODULES.json build.mk build_llvm_config.sh
EXTRA_DIST=build.mk build_llvm_config.sh
if ENABLE_LLVM
@@ -9,11 +9,15 @@ else
llvm_config=llvm-config
endif
if HAVE_STATIC_ZLIB
llvm_extra_libs = $(STATIC_ZLIB_PATH)
else
if HAVE_ZLIB
llvm_extra_libs=-lz
else
llvm_extra_libs=
endif
endif
if INTERNAL_LLVM
@@ -22,7 +26,7 @@ all-local: configure-llvm build-llvm install-llvm llvm_config.mk
clean-local: clean-llvm clean-llvm-config
$(mono_build_root)/llvm/llvm_config.mk: install-llvm
$(top_srcdir)/llvm/build_llvm_config.sh "$(top_srcdir)/llvm/usr/bin/$(llvm_config)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" > $@
$(top_srcdir)/llvm/build_llvm_config.sh "$(top_srcdir)/llvm/usr/bin/$(llvm_config)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" | tee $@
else
all-local: llvm_config.mk
@@ -30,7 +34,7 @@ all-local: llvm_config.mk
clean-local: clean-llvm-config
$(mono_build_root)/llvm/llvm_config.mk: $(top_srcdir)/llvm/Makefile.am
$(top_srcdir)/llvm/build_llvm_config.sh "$(EXTERNAL_LLVM_CONFIG)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" > $@
$(top_srcdir)/llvm/build_llvm_config.sh "$(EXTERNAL_LLVM_CONFIG)" "$(LLVM_CODEGEN_LIBS)" "$(llvm_extra_libs)" | tee $@
endif
llvm_config.mk: $(mono_build_root)/llvm/llvm_config.mk
-10
View File
@@ -1,10 +0,0 @@
[
{
"name": "llvm",
"url": "git://github.com/mono/llvm.git",
"rev": "349752c464c5fc93b32e7d45825f2890c85c8b7d",
"remote-branch": "origin/release_60",
"branch": "release_60",
"directory": "llvm"
}
]
+10 -42
View File
@@ -1,54 +1,22 @@
#
# Conditional submodule for llvm
#
# make reset-llvm will checkout a version of llvm which is suitable for this version of mono
# into $top_srcdir/llvm/llvm.
#
# Input variables
# - LLVM_TARGET: if set to wasm32 will trigger a 32bits build that enable the experimental WebAssembly backend
#
abs_top_srcdir ?= $(abspath $(CURDIR)/..)
top_srcdir ?= $(abspath $(CURDIR)/..)
LLVM_BUILD ?= $(abspath $(abs_top_srcdir)/llvm/build)
LLVM_PREFIX ?= $(abspath $(abs_top_srcdir)/llvm/usr)
LLVM_PATH ?= $(abspath $(top_srcdir)/external/llvm)
LLVM_BUILD ?= $(abspath $(top_srcdir)/llvm/build)
LLVM_PREFIX ?= $(abspath $(top_srcdir)/llvm/usr)
# LLVM_BRANCH := $(shell git -C "$(abs_top_srcdir)/external/llvm" rev-parse --abbrev-ref HEAD)
LLVM_VERSION := $(shell git -C "$(abs_top_srcdir)/external/llvm" rev-parse HEAD)
# FIXME: URL should be http://xamjenkinsartifact.blob.core.windows.net/build-package-osx-llvm-$(NEEDED_LLVM_BRANCH)/llvm-osx64-$(NEEDED_LLVM_VERSION).tar.gz
LLVM_DOWNLOAD_LOCATION = "http://xamjenkinsartifact.blob.core.windows.net/build-package-osx-llvm-release60/llvm-osx64-$(NEEDED_LLVM_VERSION).tar.gz"
# FIXME: URL should be http://xamjenkinsartifact.blob.core.windows.net/build-package-osx-llvm-$(LLVM_BRANCH)/llvm-osx64-$(LLVM_VERSION).tar.gz
LLVM_DOWNLOAD_LOCATION = "http://xamjenkinsartifact.blob.core.windows.net/build-package-osx-llvm-release60/llvm-osx64-$(LLVM_VERSION).tar.gz"
CMAKE := $(or $(CMAKE),$(shell which cmake))
NINJA := $(shell which ninja)
SUBMODULES_CONFIG_FILE = $(top_srcdir)/llvm/SUBMODULES.json
include $(top_srcdir)/scripts/submodules/versions.mk
$(eval $(call ValidateVersionTemplate,llvm,LLVM))
# Bump the given submodule to the revision given by the REV make variable
# If COMMIT is 1, commit the change
bump-llvm: __bump-version-llvm
# Bump the given submodule to the branch given by the BRANCH/REMOTE_BRANCH make variables
# If COMMIT is 1, commit the change
bump-branch-llvm: __bump-branch-llvm
# Bump the given submodule to its current GIT version
# If COMMIT is 1, commit the change
bump-current-llvm: __bump-current-version-llvm
$(LLVM_BUILD) $(LLVM_PREFIX):
mkdir -p $@
$(LLVM_PATH):
$(MAKE) -f build.mk reset-llvm
$(LLVM_PATH)/CMakeLists.txt: | $(LLVM_PATH)
EXTRA_LLVM_ARGS = $(if $(filter $(LLVM_TARGET),wasm32), -DLLVM_BUILD_32_BITS=On -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD="WebAssembly",)
# -DLLVM_ENABLE_LIBXML2=Off is needed because xml2 is not used and it breaks 32-bit builds on 64-bit Linux hosts
$(LLVM_BUILD)/$(if $(NINJA),build.ninja,Makefile): $(LLVM_PATH)/CMakeLists.txt | $(LLVM_BUILD)
$(LLVM_BUILD)/$(if $(NINJA),build.ninja,Makefile): $(abs_top_srcdir)/external/llvm/CMakeLists.txt
mkdir -p $(LLVM_BUILD) $(LLVM_PREFIX)
cd $(LLVM_BUILD) && $(CMAKE) \
$(if $(NINJA),-G Ninja) \
-DCMAKE_INSTALL_PREFIX="$(LLVM_PREFIX)" \
@@ -77,7 +45,7 @@ build-llvm: configure-llvm
DESTDIR="" $(if $(NINJA),$(NINJA),$(MAKE)) -C $(LLVM_BUILD)
.PHONY: install-llvm
install-llvm: build-llvm | $(LLVM_PREFIX)
install-llvm: build-llvm
DESTDIR="" $(if $(NINJA),$(NINJA),$(MAKE)) -C $(LLVM_BUILD) install
.PHONY: download-llvm
+2 -2
View File
@@ -139,10 +139,10 @@ fi
if [[ $llvm_config_cflags = *"stdlib=libc++"* ]]; then
llvm_libc_c="-stdlib=libc++"
llvm_libc_link="-lc++"
# llvm_libc_link="-lc++"
else
llvm_libc_c=""
llvm_libc_link="-lstdc++"
# llvm_libc_link="-lstdc++"
fi
if [[ $llvm_host_win32 = 1 ]]; then
+33 -48
View File
@@ -28,7 +28,7 @@ to it. The
.I file
is an ECMA assembly. They typically have a .exe or .dll extension.
.PP
These executables can reference additionaly functionality in the form
These executables can reference additional functionality in the form
of assembly references. By default those assembly references are
resolved as follows: the \fBmscorlib.dll\fR is resolved from the
system profile that is configured by Mono, and other assemblies are
@@ -37,8 +37,8 @@ loaded from the Global Assembly Cache (GAC).
The runtime contains a native code generator that transforms the
Common Intermediate Language into native code.
.PP
The code generator can operate in two modes: just in time compilation
(JIT) or ahead of time compilation (AOT). Since code can be
The code generator can operate in two modes: Just-in-time compilation
(JIT) or Ahead-of-time compilation (AOT). Since code can be
dynamically loaded, the runtime environment and the JIT are always
present, even if code is compiled ahead of time.
.PP
@@ -215,18 +215,36 @@ and
options. This feature is experimental.
.TP
.I llvmopts=[options]
Use this option to override the built-in set of flags passed to the
LLVM optimizer. The list of possible flags that can be passed can be
obtained by calling the bundled
Use this option to add more flags to the built-in set of flags passed to the
LLVM optimizer. When you invoke the
.I mono
command with the
.I --aot=llvm
it displays the current list of flags that are being passed to the
.I opt
program that comes with Mono.
command.
.I The list of possible flags that can be passed can be
obtained by calling the bundled
.I opt
program that comes with Mono, and calling it like this:
.nf
opt --help
.fi
.TP
.I llvmllc=[options]
Use this option to override the built-in set of flags passed to the
Use this option to add more flags to the built-in set of flags passed to the
LLVM static compiler (llc). The list of possible flags that can be passed can be
obtained by calling the bundled
.I llc
program that comes with Mono.
program that comes with Mono, and calling it like this:
.nf
llc --help
.fi
.TP
.I llvm-outfile=[filename]
Gives the path for the temporary LLVM bitcode file created during AOT.
@@ -618,47 +636,14 @@ running a 1.1 program on a 2.0 version:
mono --runtime=v2.0.50727 program.exe
.fi
.TP
\fB--security\fR, \fB--security=mode\fR
Activate the security manager, a currently experimental feature in
Mono and it is OFF by default. The new code verifier can be enabled
with this option as well.
.RS
.ne 8
.PP
Using security without parameters is equivalent as calling it with the
"cas" parameter.
.PP
The following modes are supported:
.TP
.I core-clr
Enables the core-clr security system, typically used for
Moonlight/Silverlight applications. It provides a much simpler
security system than CAS, see http://www.mono-project.com/docs/web/moonlight/
for more details and links to the descriptions of this new system.
.TP
.I validil
Enables the new verifier and performs basic verification for code
validity. In this mode, unsafe code and P/Invoke are allowed. This
mode provides a better safety guarantee but it is still possible
for managed code to crash Mono.
.TP
.I verifiable
Enables the new verifier and performs full verification of the code
being executed. It only allows verifiable code to be executed.
Unsafe code is not allowed but P/Invoke is. This mode should
not allow managed code to crash mono. The verification is not as
strict as ECMA 335 standard in order to stay compatible with the MS
runtime.
.PP
The security system acts on user code: code contained in mscorlib or
the global assembly cache is always trusted.
.ne
.RE
.TP
\fB--server\fR
Configures the virtual machine to be better suited for server
operations (currently, allows a heavier threadpool initialization).
.TP
\fB--use-map-jit\fR
Instructs Mono to generate code using MAP_JIT on MacOS. Necessary for
bundled applications.
.TP
\fB--verify-all\fR
Verifies mscorlib and assemblies in the global
assembly cache for valid IL, and all user code for IL
@@ -830,7 +815,7 @@ This compiles a method (namespace.name:methodname), this is used for
testing the compiler performance or to examine the output of the code
generator.
.TP
\fB--compileall\fR
\fB--compile-all\fR
Compiles all the methods in an assembly. This is used to test the
compiler performance or to examine the output of the code generator
.TP
@@ -854,7 +839,7 @@ on.
.TP
\fB--ncompile\fR
Instruct the runtime on the number of times that the method specified
by --compile (or all the methods if --compileall is used) to be
by --compile (or all the methods if --compile-all is used) to be
compiled. This is used for testing the code generator performance.
.TP
\fB--stats\fR
+1 -1
View File
@@ -27,7 +27,7 @@ The Private Key File (pvk) that contains the private key used to digitally
sign the PE executable. This private key must match the public key inside the
publisher X.509 certificate.
.TP
.I "-a sha1 | md5"
.I "-a sha1 | md5 | sha2 | sha256 | sha384 | sha512"
The hash algorithm used in the digital signature of the PE executable. The
default algorithm is SHA1.
.TP
+21 -14
View File
@@ -1,11 +1,10 @@
thisdir := .
SUBDIRS := build jay mcs class nunit24 ilasm tools tests errors docs packages
SUBDIRS := build jay mcs class ilasm tools tests errors docs packages
# Resgen is corlib specific tool
basic_SUBDIRS := build jay class
build_SUBDIRS := build class class/aot-compiler tools ilasm
build_SUBDIRS := build jay tools/gensources class class/aot-compiler tools
monodroid_SUBDIRS := build class tools
monodroid_tools_SUBDIRS := build class tools
monotouch_SUBDIRS := build class tools
@@ -14,11 +13,13 @@ monotouch_tv_SUBDIRS := build class
monotouch_runtime_SUBDIRS := build class
monotouch_watch_runtime_SUBDIRS := build class
monotouch_tv_runtime_SUBDIRS := build class
monotouch_tools_SUBDIRS := build class tools
xammac_SUBDIRS := build class
testing_aot_full_interp_SUBDIRS := build class
testing_aot_hybrid_SUBDIRS := build class
testing_aot_full_SUBDIRS := build class
binary_reference_assemblies_SUBDIRS := build class
net_4_x_SUBDIRS := build class nunit24 ilasm tools tests errors docs mcs class/aot-compiler packages
net_4_x_SUBDIRS := build class ilasm tools tests errors docs mcs class/aot-compiler packages
xammac_net_4_5_SUBDIRS := build class
xbuild_12_SUBDIRS := build class tools/xbuild
xbuild_14_SUBDIRS := build class tools/xbuild
@@ -26,6 +27,8 @@ winaot_SUBDIRS := build class
orbis_SUBDIRS := build class
unreal_SUBDIRS := build class
wasm_SUBDIRS := build class
wasm_tools_SUBDIRS := build class tools
netcore_SUBDIRS := build class
include build/rules.make
@@ -36,14 +39,14 @@ all-local $(STD_TARGETS:=-local):
@:
dir-check:
@if [ "$(NO_DIR_CHECK)" = "" -a "$(PROFILE)" != "basic" ]; then $(MAKE) -C ../runtime; fi
@if [ "$(NO_DIR_CHECK)" = "" ]; then $(MAKE) -C ../runtime; fi
# fun specialty targets
PROFILES = net_4_x binary_reference_assemblies xbuild_12 xbuild_14
.PHONY: all-profiles $(STD_TARGETS:=-profiles)
all-profiles $(STD_TARGETS:=-profiles): %-profiles: profiles-do--%
.PHONY: all-profiles compiler-test-profiles run-compiler-test-profiles $(STD_TARGETS:=-profiles)
all-profiles compiler-test-profiles run-compiler-test-profiles $(STD_TARGETS:=-profiles): %-profiles: profiles-do--%
@:
profiles-do--%:
@@ -75,21 +78,25 @@ $(_boot_:%=profile-do--monotouch_tv--%): profile-do--monotouch_tv--%:
$(_boot_:%=profile-do--monotouch_runtime--%): profile-do--monotouch_runtime--%: profile-do--build--%
$(_boot_:%=profile-do--monotouch_watch_runtime--%): profile-do--monotouch_watch_runtime--%: profile-do--build--%
$(_boot_:%=profile-do--monotouch_tv_runtime--%): profile-do--monotouch_tv_runtime--%: profile-do--build--%
$(_boot_:%=profile-do--monotouch_tools--%): profile-do--monotouch_tools--%: profile-do--build--%
$(_boot_:%=profile-do--xammac--%): profile-do--xammac--%: profile-do--build--%
$(_boot_:%=profile-do--xammac_net_4_5--%): profile-do--xammac_net_4_5--%: profile-do--build--%
$(_boot_:%=profile-do--testing_aot_full_interp--%): profile-do--testing_aot_full_interp--%: profile-do--build--%
$(_boot_:%=profile-do--testing_aot_hybrid--%): profile-do--testing_aot_hybrid--%: profile-do--build--%
$(_boot_:%=profile-do--testing_aot_full--%): profile-do--testing_aot_full--%: profile-do--build--%
$(_boot_:%=profile-do--winaot--%): profile-do--winaot--%: profile-do--build--%
$(_boot_:%=profile-do--orbis--%): profile-do--orbis--%: profile-do--build--%
$(_boot_:%=profile-do--unreal--%): profile-do--unreal--%: profile-do--build--%
$(_boot_:%=profile-do--wasm--%): profile-do--wasm--%: profile-do--build--%
$(_boot_:%=profile-do--build--%): profile-do--build--%: profile-do--basic--%
$(_boot_:%=profile-do--wasm_tools--%): profile-do--wasm_tools--%: profile-do--build--%
testcorlib:
@cd class/corlib && $(MAKE) test run-test
compiler-test:
$(MAKE) -C tests test
$(MAKE) -C errors test
compiler-tests:
$(MAKE) TEST_SUBDIRS="tests errors" run-test-profiles
run-compiler-test:
$(MAKE) -C tests run-test
$(MAKE) -C errors run-test
package := mcs-$(VERSION)
@@ -146,9 +153,9 @@ distcheck: dist-tarball
# Targets for creating API diffs of the framework
MONO_API_SNAPSHOT_PATH := $(topdir)../external/api-snapshot/
GENAPI := $(MONO_API_SNAPSHOT_PATH)tools/genapi/GenAPI.exe
GENAPI := $(MONO_API_SNAPSHOT_PATH)tools/genapi/Microsoft.DotNet.GenAPI.exe
MONO_API_SNAPSHOT_PROFILE_PATH := $(MONO_API_SNAPSHOT_PATH)profiles/$(PROFILE)/
MONO_API_ASSEMBLIES_IGNORED := $(addprefix $(topdir)class/lib/$(PROFILE)/, Mono.CSharp.dll SystemWebTestShim.dll standalone-runner-support.dll nunit.core.dll nunit.core.extensions.dll nunit.core.interfaces.dll nunit.framework.dll nunit.framework.extensions.dll nunit.mocks.dll nunit.util.dll nunit-console-runner.dll nunitlite.dll Mono.Profiler.Log.dll)
MONO_API_ASSEMBLIES_IGNORED := $(addprefix $(topdir)class/lib/$(PROFILE)/, Mono.CSharp.dll SystemWebTestShim.dll standalone-runner-support.dll nunitlite.dll Mono.Profiler.Log.dll)
MONO_API_ASSEMBLIES := $(filter-out $(MONO_API_ASSEMBLIES_IGNORED), $(wildcard $(topdir)class/lib/$(PROFILE)/*.dll)) $(wildcard $(topdir)class/lib/$(PROFILE)/Facades/*.dll)
MONO_API_ASSEMBLIES_CS := $(MONO_API_ASSEMBLIES:$(topdir)class/lib/$(PROFILE)/%.dll=$(MONO_API_SNAPSHOT_PROFILE_PATH)%.cs)
-3
View File
@@ -34,9 +34,6 @@ package module which drives the compilation of this directory.
mcs/
The Mono C# compiler
nunit24/
An old copy of the NUnit 2.4 library that we ship for historical reasons.
packages/
Integrates some packages from NuGet (like Roslyn) into the build system.
+5 -3
View File
@@ -2,7 +2,7 @@ thisdir = build
SUBDIRS =
include ../build/rules.make
BUILT_FILES = common/Consts.cs $(topdir)/class/lib/$(PROFILE_DIRECTORY)/Consts.cs
BUILT_FILES = common/Consts.cs $(topdir)/class/lib/$(PROFILE_DIRECTORY)/Consts.cs common/sourcelink.json
all-local install-local test-local run-test-local csproj-local run-test-ondotnet-local uninstall-local doc-update-local: $(BUILT_FILES)
@:
@@ -18,9 +18,11 @@ common/Consts.cs $(topdir)/class/lib/$(PROFILE_DIRECTORY)/Consts.cs: common/Cons
test -n '$(MONO_CORLIB_VERSION)'
sed -e 's,@''MONO_VERSION@,$(MONO_VERSION),' -e 's,@''MONO_CORLIB_VERSION@,$(MONO_CORLIB_VERSION),' $< > $@
common/sourcelink.json: common/sourcelink.json.in $(wildcard config.make) | $(topdir)/class/lib/$(PROFILE_DIRECTORY)
sed -e 's,@mono_topdir@,$(shell cd $(topdir)/.. && pwd),' -e 's,@mono_commit_hash@,$(shell cd $(topdir)/.. && git rev-parse HEAD),' -e 's,@corefx_commit_hash@,$(shell cd $(topdir)/../external/corefx && git rev-parse HEAD),' -e 's,@corert_commit_hash@,$(shell cd $(topdir)/../external/corert && git rev-parse HEAD),' -e 's,@cecil_commit_hash@,$(shell cd $(topdir)/../external/cecil && git rev-parse HEAD),' $< > $@
PLATFORMS = macos linux win32 unix
PROFILES = \
basic \
build \
binary_reference_assemblies \
net_4_x \
@@ -29,6 +31,7 @@ PROFILES = \
COMMON_SRCS = \
Consts.cs.in \
sourcelink.json.in \
Locale.cs \
MonoTODOAttribute.cs \
basic-profile-check.cs \
@@ -43,7 +46,6 @@ DISTFILES = \
corcompare.make \
corcompare-api.xsl \
executable.make \
gensources.cs \
library.make \
rules.make \
tests.make \
+1
View File
@@ -1 +1,2 @@
/Consts.cs
/sourcelink.json
+19 -8
View File
@@ -28,7 +28,14 @@
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
static class Consts
static partial class Consts
{
public const string MonoCorlibVersion = "@MONO_CORLIB_VERSION@";
}
#if !NETCORE
static partial class Consts
{
//
// Use these assembly version constants to make code more maintainable.
@@ -38,7 +45,6 @@ static class Consts
public const string MonoCompany = "Mono development team";
public const string MonoProduct = "Mono Common Language Infrastructure";
public const string MonoCopyright = "(c) Various Mono authors";
public const string MonoCorlibVersion = "@MONO_CORLIB_VERSION@";
#if MOBILE
// Versions of .NET Framework for Silverlight 4.0
@@ -62,6 +68,13 @@ static class Consts
public const string VsVersion = "0.0.0.0"; // Useless ?
public const string VsFileVersion = "11.0.0.0"; // TODO:
#elif NETCORE
public const string FxVersion = "";
public const string FxFileVersion = "";
public const string EnvironmentVersion = FxFileVersion;
public const string VsVersion = "";
public const string VsFileVersion = "";
#elif NET_4_0
#error Profile NET_4_0 is not supported.
#elif NET_3_5
@@ -98,7 +111,7 @@ static class Consts
public const string AssemblyMono_Security = "Mono.Security, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=0738eb9f132ed756";
public const string AssemblyMono_Messaging_RabbitMQ = "Mono.Messaging.RabbitMQ, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=0738eb9f132ed756";
public const string AssemblyCorlib = "mscorlib, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=" + PublicKeyToken;
public const string AssemblySystem = "System, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b77a5c561934e089";
public const string AssemblySystem = "System, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=" + PublicKeyToken;
public const string AssemblySystem_Data = "System.Data, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b77a5c561934e089";
public const string AssemblySystem_Design = "System.Design, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";
public const string AssemblySystem_DirectoryServices = "System.DirectoryServices, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";
@@ -109,17 +122,15 @@ static class Consts
public const string AssemblySystem_ServiceProcess = "System.ServiceProcess, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";
public const string AssemblySystem_Web = "System.Web, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a";
public const string AssemblySystem_Windows_Forms = "System.Windows.Forms, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b77a5c561934e089";
#if NET_4_0
public const string AssemblySystem_2_0 = "System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
public const string AssemblySystemCore_3_5 = "System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
public const string AssemblySystem_Core = "System.Core, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b77a5c561934e089";
public const string AssemblySystem_Core = "System.Core, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=" + PublicKeyToken;
public const string WindowsBase_3_0 = "WindowsBase, Version=3.0.0.0, PublicKeyToken=31bf3856ad364e35";
public const string AssemblyWindowsBase = "WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";
public const string AssemblyPresentationCore_3_5 = "PresentationCore, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";
public const string AssemblyPresentationCore_4_0 = "PresentationCore, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";
public const string AssemblyPresentationFramework_3_5 = "PresentationFramework, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35";
public const string AssemblySystemServiceModel_3_0 = "System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
#elif MOBILE
public const string AssemblySystem_Core = "System.Core, Version=" + FxVersion + ", Culture=neutral, PublicKeyToken=b77a5c561934e089";
#endif
}
#endif
+5
View File
@@ -41,6 +41,11 @@ static partial class SR
return string.Format (CultureInfo.InvariantCulture, resourceFormat, p1, p2);
}
internal static string Format(CultureInfo ci, string resourceFormat, object p1, object p2)
{
return string.Format (ci, resourceFormat, p1, p2);
}
internal static string Format(string resourceFormat, object p1, object p2, object p3)
{
return string.Format (CultureInfo.InvariantCulture, resourceFormat, p1, p2, p3);
+8
View File
@@ -0,0 +1,8 @@
{
"documents": {
"@mono_topdir@/external/corefx/*": "https://raw.githubusercontent.com/mono/corefx/@corefx_commit_hash@/*",
"@mono_topdir@/external/corert/*": "https://raw.githubusercontent.com/mono/corert/@corert_commit_hash@/*",
"@mono_topdir@/external/cecil/*": "https://raw.githubusercontent.com/mono/cecil/@cecil_commit_hash@/*",
"@mono_topdir@/*": "https://raw.githubusercontent.com/mono/mono/@mono_commit_hash@/*"
}
}
+13 -15
View File
@@ -60,11 +60,9 @@ endif
the_libdir_base = $(topdir)/class/$(lib_dir)/$(PROFILE_DIRECTORY)/$(if $(LIBRARY_SUBDIR),$(LIBRARY_SUBDIR)/)
ifdef RESOURCE_STRINGS
ifneq (basic, $(PROFILE))
RESOURCE_STRINGS_FILES += $(RESOURCE_STRINGS:%=--resourcestrings:%)
IL_REPLACE_FILES += $(IL_REPLACE:%=--ilreplace:%)
endif
endif
ifdef ENFORCE_LIBRARY_WARN_AS_ERROR
ifeq ($(LIBRARY_WARN_AS_ERROR),yes)
@@ -74,6 +72,11 @@ endif
endif
endif
# add sourcelink information if we're building a portable PDB
ifneq (, $(findstring debug:portable, $(PROFILE_MCS_FLAGS)))
LIB_MCS_FLAGS += -sourcelink:$(topdir)/build/common/sourcelink.json
endif
the_libdir = $(the_libdir_base)$(intermediate)
ifdef LIBRARY_USE_INTERMEDIATE_FILE
@@ -286,18 +289,13 @@ endif
# The library
# If the directory contains the per profile include file, generate list file.
# TODO: depend on all *.sources for now and figure out how to list only needed files later
PROFILE_sources = $(wildcard *.sources)
ifneq "x" "x$(PROFILE_RUNTIME)"
GENSOURCES_RUNTIME=$(PROFILE_RUNTIME)
else
GENSOURCES_RUNTIME=MONO_PATH="$(GENSOURCES_LIBDIR)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME)
endif
# TODO: depend on all *.sources (except tests) for now and figure out how to list only needed files later
PROFILE_sources = $(filter-out %test.dll.exclude.sources %test.dll.sources, $(wildcard *.sources))
PROFILE_excludes = $(filter-out %test.dll.exclude.sources %test.dll.sources, $(wildcard *.exclude.sources))
sourcefile = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(LIBRARY_SUBDIR)_$(LIBRARY).sources
$(sourcefile): $(PROFILE_sources) $(PROFILE_excludes) $(depsdir)/.stamp $(GENSOURCES_CS)
$(GENSOURCES_RUNTIME) --debug $(GENSOURCES_EXE) --strict "$@" "$(LIBRARY)" "$(PROFILE_PLATFORM)" "$(PROFILE)"
$(sourcefile): $(PROFILE_sources) $(PROFILE_excludes) $(depsdir)/.stamp
$(GENSOURCES) --strict --platformsdir:$(topdir)/build "$@" "$(LIBRARY)" "$(PROFILE_PLATFORM)" "$(PROFILE)"
library_CLEAN_FILES += $(sourcefile)
@@ -354,7 +352,7 @@ library_CLEAN_FILES += $(PROFILE)_$(LIBRARY_NAME)_aot.log
ifdef PLATFORM_AOT_SUFFIX
$(the_lib)$(PLATFORM_AOT_SUFFIX): $(the_lib)
$(Q_AOT) MONO_PATH='$(the_libdir_base)' > $(PROFILE)_$(LIBRARY_NAME)_aot.log 2>&1 $(RUNTIME) $(AOT_BUILD_FLAGS) --debug $(the_lib)
$(Q_AOT) MONO_PATH='$(the_libdir_base)' $(RUNTIME) $(AOT_BUILD_FLAGS) --debug $(the_lib)
all-local-aot: $(the_lib)$(PLATFORM_AOT_SUFFIX)
endif
@@ -389,5 +387,5 @@ ifneq ($(RESX_STRINGS),)
endif
update-corefx-sr: $(RESX_RESOURCE_STRING) $(XTEST_RESX_RESOURCE_STRING)
make SR_OUTPUT=corefx/SR.cs RESX_STRINGS="$(RESX_RESOURCE_STRING)" RESX_EXTRA_ARGUMENTS="$(RESX_EXTRA_ARGUMENTS)" update-corefx-sr-generic \
&& make SR_OUTPUT=corefx/SR.tests.cs RESX_STRINGS=$(XTEST_RESX_RESOURCE_STRING) update-corefx-sr-generic
$(MAKE) SR_OUTPUT=corefx/SR.cs RESX_STRINGS="$(RESX_RESOURCE_STRING)" RESX_EXTRA_ARGUMENTS="$(RESX_EXTRA_ARGUMENTS)" update-corefx-sr-generic \
&& $(MAKE) SR_OUTPUT=corefx/SR.tests.cs RESX_STRINGS=$(XTEST_RESX_RESOURCE_STRING) update-corefx-sr-generic
+2
View File
@@ -34,3 +34,5 @@ platform-check:
# echo "*** You need to build MCS with GNU make. Try \`gmake'" ; \
# exit 1 ; \
# fi
PLATFORM_LINUX=1
+1 -1
View File
@@ -6,7 +6,7 @@
PLATFORM_MCS_FLAGS =
PLATFORM_RUNTIME = $(RUNTIME)
PLATFORM_CORLIB = mscorlib.dll
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnMac,MacNotWorking,
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnMac
EXTERNAL_MCS = mcs
EXTERNAL_MBAS = mbas
+3
View File
@@ -34,3 +34,6 @@ platform-check:
# echo "*** You need to build MCS with GNU make. Try \`gmake'" ; \
# exit 1 ; \
# fi
PLATFORM_UNIX=1
+1 -1
View File
@@ -6,7 +6,7 @@
PLATFORM_MCS_FLAGS =
PLATFORM_RUNTIME =
PLATFORM_CORLIB = mscorlib.dll
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnWindows,
PLATFORM_TEST_HARNESS_EXCLUDES = NotOnWindows
EXTERNAL_MCS = mcs
EXTERNAL_MBAS = vbc.exe
-129
View File
@@ -1,129 +0,0 @@
# -*- makefile -*-
monolite_path := $(topdir)/class/lib/monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)
with_mono_path_monolite = MONO_PATH="$(monolite_path)$(PLATFORM_PATH_SEPARATOR)$(monolite_path)/Facades$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH"
monolite_flag := $(depsdir)/use-monolite
use_monolite := $(wildcard $(monolite_flag))
MONOLITE_MSCORLIB = $(monolite_path)/mscorlib.dll
ifdef use_monolite
ifdef MCS_MODE
CSC_LOCATION = $(monolite_path)/mcs.exe
endif
PROFILE_RUNTIME = $(with_mono_path_monolite) $(RUNTIME)
BOOTSTRAP_MCS = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(CSC_LOCATION)
else
PROFILE_RUNTIME = $(EXTERNAL_RUNTIME)
ifdef MCS_MODE
BOOTSTRAP_MCS = mcs
else
BOOTSTRAP_MCS = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(CSC_LOCATION)
endif
endif
ILASM = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/ilasm.exe
STRING_REPLACER = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/tmp/cil-stringreplacer.exe
MCS = $(BOOTSTRAP_MCS)
GENSOURCES_CS = $(topdir)/build/gensources.cs
GENSOURCES_DIR = $(topdir)/build
GENSOURCES_EXE = $(GENSOURCES_DIR)/gensources.exe
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:MONO -d:WIN_PLATFORM -d:BOOTSTRAP_BASIC -nowarn:1699 -nostdlib
API_BIN_PROFILE = v4.7.1
NO_SIGN_ASSEMBLY = yes
NO_TEST = yes
NO_INSTALL = yes
FRAMEWORK_VERSION = 4.5
# Compiler all using same bootstrap compiler
LIBRARY_COMPILE = $(BOOT_COMPILE)
# Verbose basic only
# V = 1
#
# Copy from rules.make because I don't know how to unset MCS_FLAGS
#
USE_MCS_FLAGS = /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
.PHONY: profile-check do-profile-check
profile-check:
@:
ifeq (.,$(thisdir))
all-recursive: do-profile-check
all-local: post-profile-cleanup
clean-local: clean-profile
endif
clean-profile:
-rm -f $(PROFILE_EXE) $(PROFILE_OUT) $(monolite_flag)
post-profile-cleanup:
@rm -f $(monolite_flag)
PROFILE_EXE = $(depsdir)/basic-profile-check.exe
PROFILE_OUT = $(PROFILE_EXE:.exe=.out)
MAKE_Q=$(if $(V),,-s)
do-profile-check: $(depsdir)/.stamp
@ok=:; \
rm -f $(PROFILE_EXE) $(PROFILE_OUT); \
if [ -z '$(MAKE_Q)' ] && [ -n '$(PROFILE_RUNTIME)' ]; then $(PROFILE_RUNTIME) --version; fi; \
$(MAKE) $(MAKE_Q) $(PROFILE_OUT) || ok=false; \
if $$ok; then rm -f $(PROFILE_EXE) $(PROFILE_OUT); else \
if test ! -s $(MONOLITE_MSCORLIB); then \
$(MAKE) $(MAKE_Q) do-get-monolite ; \
fi; \
if test -f $(MONOLITE_MSCORLIB); then \
$(MAKE) $(MAKE_Q) do-profile-check-monolite ; \
else \
echo "*** The runtime '$(PROFILE_RUNTIME)' doesn't appear to be usable." 1>&2; \
echo "*** Check README for information on how to bootstrap a Mono installation." 1>&2 ; \
exit 1; fi; fi
ifdef use_monolite
do-get-monolite:
do-profile-check-monolite:
@echo "*** The contents of your 'monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)' directory may be out-of-date" 1>&2
@echo "*** You may want to try 'make get-monolite-latest'" 1>&2
rm -f $(monolite_flag)
exit 1
else
do-get-monolite:
@echo "*** Downloading bootstrap required 'monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)'" 1>&2
$(MAKE) $(MAKE_Q) -C $(topdir)/class get-monolite-latest
do-profile-check-monolite: $(depsdir)/.stamp
@echo "*** The runtime '$(PROFILE_RUNTIME)' doesn't appear to be usable." 1>&2
@echo "*** Trying the 'monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)' directory." 1>&2
@echo dummy > $(monolite_flag)
$(MAKE) do-profile-check
endif
$(PROFILE_EXE): $(topdir)/build/common/basic-profile-check.cs $(GENSOURCES_CS)
$(MAKE) $(MAKE_Q) -C $(topdir)/packages
$(BOOTSTRAP_MCS) /warn:0 /noconfig /langversion:latest /r:System.dll /r:mscorlib.dll /out:[email protected] $<
$(BOOTSTRAP_MCS) /noconfig /langversion:latest /r:mscorlib.dll /r:System.dll /r:System.Core.dll /out:$(GENSOURCES_EXE).tmp $(GENSOURCES_CS)
- rm $(GENSOURCES_EXE)
mv $(GENSOURCES_EXE).tmp $(GENSOURCES_EXE)
- rm -f $@
mv [email protected] $@
$(PROFILE_OUT): $(PROFILE_EXE)
$(PROFILE_RUNTIME) $< > $@ 2>&1
+139 -10
View File
@@ -1,25 +1,154 @@
# -*- makefile -*-
BOOTSTRAP_PROFILE = basic
BUILD_TOOLS_PROFILE = basic
monolite_path := $(topdir)/class/lib/monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)
with_mono_path_monolite = MONO_PATH="$(monolite_path)$(PLATFORM_PATH_SEPARATOR)$(monolite_path)/Facades$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH"
monolite_flag := $(depsdir)/use-monolite
use_monolite := $(wildcard $(monolite_flag))
MONOLITE_MSCORLIB = $(monolite_path)/mscorlib.dll
ifdef use_monolite
ifdef MCS_MODE
CSC_LOCATION = $(monolite_path)/mcs.exe
endif
PROFILE_RUNTIME = $(with_mono_path_monolite) $(RUNTIME)
BOOTSTRAP_MCS = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(CSC_LOCATION)
else
PROFILE_RUNTIME = $(EXTERNAL_RUNTIME)
ifdef MCS_MODE
BOOTSTRAP_MCS = mcs
else
BOOTSTRAP_MCS = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(CSC_LOCATION)
endif
endif
#
# Special setup for boostrap tools which we want to run with system/monolite core libraries
# for all libraries build as part of this profile
#
ILASM = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/tmp/ilasm.exe
STRING_REPLACER = $(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/tmp/cil-stringreplacer.exe
GENSOURCES =$(PROFILE_RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/tmp/gensources.exe
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
PLATFORMS = macos linux win32 unix
# nuttzing!
profile-check:
@:
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:MONO -d:WIN_PLATFORM -nowarn:1699 -nostdlib
PROFILE_MCS_FLAGS = -d:NET_4_0 -d:NET_4_5 -d:MONO -d:WIN_PLATFORM -d:BOOTSTRAP_BASIC -nowarn:1699 -nostdlib
API_BIN_PROFILE = v4.7.1
BOOTSTRAP_BIN_PROFILE = v4.7
NO_SIGN_ASSEMBLY = yes
NO_TEST = yes
NO_INSTALL = yes
FRAMEWORK_VERSION = 4.5
# Compiler all using same bootstrap compiler
LIBRARY_COMPILE = $(BOOT_COMPILE)
# Verbose basic only
# V = 1
#
# Copy from rules.make because I don't know how to unset MCS_FLAGS
#
ifeq ("$(ENABLE_COMPILER_SERVER)","1")
COMPILER_SERVER_ARGS=/shared:$(COMPILER_SERVER_PIPENAME)
else
COMPILER_SERVER_ARGS:=
endif
USE_MCS_FLAGS = $(COMPILER_SERVER_ARGS) /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
.PHONY: profile-check do-profile-check
profile-check:
@:
ifeq (.,$(thisdir))
all-recursive: do-profile-check
all-local: post-profile-cleanup
clean-local: clean-profile
endif
clean-profile:
-rm -f $(PROFILE_EXE) $(PROFILE_OUT) $(monolite_flag)
post-profile-cleanup:
@rm -f $(monolite_flag)
$(MAKE) $(MAKE_Q) start-compiler-server
PROFILE_EXE = $(depsdir)/basic-profile-check.exe
PROFILE_OUT = $(PROFILE_EXE:.exe=.out)
MAKE_Q=$(if $(V),,-s)
do-profile-check: $(depsdir)/.stamp
@ok=:; \
rm -f $(PROFILE_EXE) $(PROFILE_OUT); \
if [ -z '$(MAKE_Q)' ] && [ -n '$(PROFILE_RUNTIME)' ]; then $(PROFILE_RUNTIME) --version; fi; \
$(MAKE) $(MAKE_Q) $(PROFILE_OUT) || ok=false; \
if $$ok; then rm -f $(PROFILE_EXE) $(PROFILE_OUT); else \
if test ! -s $(MONOLITE_MSCORLIB); then \
$(MAKE) $(MAKE_Q) do-get-monolite ; \
fi; \
if test -f $(MONOLITE_MSCORLIB); then \
$(MAKE) $(MAKE_Q) do-profile-check-monolite ; \
else \
echo "*** The runtime '$(PROFILE_RUNTIME)' doesn't appear to be usable." 1>&2; \
echo "*** Check README for information on how to bootstrap a Mono installation." 1>&2 ; \
exit 1; fi; fi
ifdef use_monolite
do-get-monolite:
do-profile-check-monolite:
@echo "*** The contents of your 'monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)' directory may be out-of-date" 1>&2
@echo "*** You may want to try 'make get-monolite-latest'" 1>&2
rm -f $(monolite_flag)
exit 1
else
do-get-monolite:
@echo "*** Downloading bootstrap required 'monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)'" 1>&2
$(MAKE) $(MAKE_Q) -C $(topdir)/class get-monolite-latest
do-profile-check-monolite: $(depsdir)/.stamp
@echo "*** The runtime '$(PROFILE_RUNTIME)' doesn't appear to be usable." 1>&2
@echo "*** Trying the 'monolite-$(BUILD_PLATFORM)/$(MONO_CORLIB_VERSION)' directory." 1>&2
@echo dummy > $(monolite_flag)
$(MAKE) do-profile-check
endif
$(PROFILE_EXE): $(topdir)/build/common/basic-profile-check.cs
$(BOOTSTRAP_MCS) /warn:0 /noconfig /langversion:latest /r:System.dll /r:mscorlib.dll /out:$@ $<
$(PROFILE_OUT): $(PROFILE_EXE)
$(PROFILE_RUNTIME) $< > $@ 2>&1
ifeq ("$(ENABLE_COMPILER_SERVER)","1")
BUILDLIB_LOCATION=$(realpath $(topdir))/class/lib/build
MONOWRAPPER_LOCATION=$(realpath $(topdir)/../runtime/mono-wrapper)
VBCS_LOCATION?=$(dir $(SERVER_CSC_LOCATION))/VBCSCompiler.exe
VBCS_RUNTIME=MONO_PATH="$(BUILDLIB_LOCATION)$(PLATFORM_PATH_SEPARATOR)$(BUILDLIB_LOCATION)/Facades$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" '$(MONOWRAPPER_LOCATION)'
export VBCS_RUNTIME
export VBCS_LOCATION
start-compiler-server:
echo Attempting to start compiler server...
$(topdir)/build/start-compiler-server.sh '$(realpath $(topdir))' '$(realpath $(topdir)/build/compiler-server.log)' '$(COMPILER_SERVER_PIPENAME)'
else
start-compiler-server:
endif
+2
View File
@@ -34,3 +34,5 @@ NO_INSTALL = yes
MOBILE_DYNAMIC = yes
MOBILE_PROFILE = yes
NO_CONSOLE = yes
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS InetAccess AndroidNotWorking
+1 -1
View File
@@ -11,7 +11,7 @@ profile-check:
TARGET_NET_REFERENCE = v4.6
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:WIN_PLATFORM -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:MONODROID_TOOLS -d:WIN_PLATFORM -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
FRAMEWORK_VERSION = 4.5
+4
View File
@@ -2,3 +2,7 @@ include $(topdir)/build/profiles/monotouch_runtime.make
PROFILE_MCS_FLAGS += \
-d:FULL_AOT_RUNTIME
NO_SRE = yes
PROFILE_TEST_HARNESS_EXCLUDES += SRE NotWorkingLinqInterpreter
+3 -1
View File
@@ -39,4 +39,6 @@ NO_CONSOLE = yes
PROFILE_DISABLE_BTLS=1
MONO_FEATURE_APPLETLS=1
ONLY_APPLETLS=1
ENABLE_GSS=1
ENABLE_GSS=1
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS InetAccess
+18
View File
@@ -0,0 +1,18 @@
# -*- makefile -*-
BOOTSTRAP_PROFILE = build
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
profile-check:
@:
TARGET_NET_REFERENCE = v4.6
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:MONOTOUCH_TOOLS -d:WIN_PLATFORM -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
FRAMEWORK_VERSION = 4.5
NO_INSTALL = yes
+1 -1
View File
@@ -7,5 +7,5 @@ NO_THREAD_ABORT=1
NO_THREAD_SUSPEND_RESUME=1
NO_MULTIPLE_APPDOMAINS=1
NO_PROCESS_START=1
NO_GSS=1
NO_VTS_TEST=1
NO_GSS=1
+16
View File
@@ -0,0 +1,16 @@
# -*- makefile -*-
BOOTSTRAP_PROFILE = build
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
PLATFORMS = macos linux win32 unix
profile-check:
@:
DEFAULT_REFERENCES =
PROFILE_MCS_FLAGS = -d:NETCORE -nostdlib $(PLATFORM_DEBUG_FLAGS)
ENFORCE_LIBRARY_WARN_AS_ERROR = yes
+4 -3
View File
@@ -34,11 +34,12 @@ FRAMEWORK_VERSION = 2.1
# the tuner takes care of the install
NO_INSTALL = yes
AOT_FRIENDLY_PROFILE = yes
ALWAYS_AOT = yes
ALWAYS_AOT_BCL = yes
ALWAYS_AOT_TESTS = yes
MOBILE_PROFILE = yes
NO_VTS_TEST = yes
NO_CONSOLE = yes
PROFILE_DISABLE_BTLS = yes
NO_SRE = yes
# Note need for trailing comma. If you add, keep it
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,PKITS,
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS SRE NotWorkingLinqInterpreter
@@ -0,0 +1,33 @@
#! -*- makefile -*-
BOOTSTRAP_PROFILE = build
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
profile-check:
@:
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = \
-d:NET_1_1 \
-d:NET_2_0 \
-d:NET_2_1 \
-d:NET_3_5 \
-d:NET_4_0 \
-d:NET_4_5 \
-d:MONO \
-d:MOBILE,MOBILE_LEGACY \
-nowarn:1699 \
-nostdlib \
$(PLATFORM_DEBUG_FLAGS)
API_BIN_PROFILE = build/monotouch
FRAMEWORK_VERSION = 2.1
NO_INSTALL = yes
NO_CONSOLE = yes
MOBILE_PROFILE = yes
PROFILE_TEST_HARNESS_EXCLUDES := MobileNotWorking PKITS
+8 -34
View File
@@ -1,44 +1,18 @@
#! -*- makefile -*-
BOOTSTRAP_PROFILE = build
include $(topdir)/build/profiles/testing_aot_common.make
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
profile-check:
@:
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = \
-d:NET_1_1 \
-d:NET_2_0 \
-d:NET_2_1 \
-d:NET_3_5 \
-d:NET_4_0 \
-d:NET_4_5 \
-d:MONO \
-d:MOBILE,MOBILE_LEGACY \
-d:FULL_AOT_DESKTOP \
PROFILE_MCS_FLAGS += \
-d:FULL_AOT_DESKTOP \
-d:FULL_AOT_RUNTIME \
-d:DISABLE_REMOTING \
-d:DISABLE_COM \
-nowarn:1699 \
-nostdlib \
$(PLATFORM_DEBUG_FLAGS)
-d:DISABLE_COM
API_BIN_PROFILE = build/monotouch
FRAMEWORK_VERSION = 2.1
# the tuner takes care of the install
NO_INSTALL = yes
AOT_FRIENDLY_PROFILE = yes
MOBILE_PROFILE = yes
NO_VTS_TEST = yes
NO_CONSOLE = yes
NO_SRE = yes
# Note need for trailing comma. If you add, keep it
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,PKITS,
ALWAYS_AOT = yes
ALWAYS_AOT_BCL = yes
ALWAYS_AOT_TESTS = yes
PROFILE_TEST_HARNESS_EXCLUDES += SRE
@@ -0,0 +1,9 @@
#! -*- makefile -*-
include $(topdir)/build/profiles/testing_aot_common.make
PROFILE_MCS_FLAGS += \
-d:FULL_AOT_INTERP \
-d:DISABLE_COM
ALWAYS_AOT_BCL = yes
+3 -28
View File
@@ -1,33 +1,8 @@
#! -*- makefile -*-
BOOTSTRAP_PROFILE = build
include $(topdir)/build/profiles/testing_aot_common.make
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
PROFILE_MCS_FLAGS += \
-d:MOBILE_DYNAMIC
profile-check:
@:
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = \
-d:NET_1_1 \
-d:NET_2_0 \
-d:NET_2_1 \
-d:MOBILE,MOBILE_LEGACY \
-d:MOBILE_DYNAMIC \
-d:NET_3_5 \
-d:NET_4_0 \
-d:NET_4_5 \
-d:MONO \
-nowarn:1699 \
-nostdlib \
$(PLATFORM_DEBUG_FLAGS)
API_BIN_PROFILE = build/monotouch
FRAMEWORK_VERSION = 2.1
NO_INSTALL = yes
MOBILE_DYNAMIC = yes
MOBILE_PROFILE = yes
NO_CONSOLE = yes
+6 -1
View File
@@ -35,7 +35,12 @@ FRAMEWORK_VERSION = 2.1
# the tuner takes care of the install
NO_INSTALL = yes
AOT_FRIENDLY_PROFILE = yes
ALWAYS_AOT = yes
ALWAYS_AOT_BCL = yes
ALWAYS_AOT_TESTS = yes
MOBILE_PROFILE = yes
NO_VTS_TEST = yes
NO_CONSOLE = yes
NO_MULTIPLE_APPDOMAINS = yes
NO_THREAD_ABORT = yes
NO_THREAD_SUSPEND_RESUME = yes
WASM = yes
+18
View File
@@ -0,0 +1,18 @@
# -*- makefile -*-
BOOTSTRAP_PROFILE = build
BOOTSTRAP_MCS = MONO_PATH="$(topdir)/class/lib/$(BOOTSTRAP_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(INTERNAL_CSC)
MCS = $(BOOTSTRAP_MCS)
profile-check:
@:
TARGET_NET_REFERENCE = v4.6
DEFAULT_REFERENCES = mscorlib
PROFILE_MCS_FLAGS = -d:NET_4_6 -d:MONO -d:WASM_TOOLS -nowarn:1699 -nostdlib $(PLATFORM_DEBUG_FLAGS)
FRAMEWORK_VERSION = 4.5
NO_INSTALL = yes
+4 -3
View File
@@ -34,9 +34,10 @@ FRAMEWORK_VERSION = 2.1
# the tuner takes care of the install
NO_INSTALL = yes
AOT_FRIENDLY_PROFILE = yes
ALWAYS_AOT = yes
ALWAYS_AOT_BCL = yes
ALWAYS_AOT_TESTS = yes
MOBILE_PROFILE = yes
NO_VTS_TEST = yes
NO_SRE = yes
# Note need for trailing comma. If you add, keep it
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking,PKITS,
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS SRE NotWorkingLinqInterpreter
+2 -1
View File
@@ -29,7 +29,6 @@ PROFILE_MCS_FLAGS = \
API_BIN_PROFILE = build/monotouch
FRAMEWORK_VERSION = 2.1
NO_TEST = yes
NO_INSTALL = yes
MOBILE_DYNAMIC = yes
MOBILE_PROFILE = yes
@@ -39,3 +38,5 @@ ENABLE_GSS=1
PROFILE_DISABLE_BTLS=1
MONO_FEATURE_APPLETLS=1
ONLY_APPLETLS=1
PROFILE_TEST_HARNESS_EXCLUDES = MobileNotWorking PKITS
+28 -20
View File
@@ -9,6 +9,7 @@
empty :=
space := $(empty) $(empty)
comma := ,
_FILTER_OUT = $(foreach x,$(2),$(if $(findstring $(1),$(x)),,$(x)))
# given $(thisdir), we compute the path to the top directory
@@ -27,15 +28,19 @@ Q_MCS=$(if $(V),,@echo "$(if $(MCS_MODE),MCS,CSC) [$(intermediate)$(PROFILE_
Q_AOT=$(if $(V),,@echo "AOT [$(intermediate)$(PROFILE_DIRECTORY)] $(notdir $(@))";)
ifndef BUILD_TOOLS_PROFILE
ifeq ($(PROFILE),basic)
BUILD_TOOLS_PROFILE = basic
else
BUILD_TOOLS_PROFILE = build
endif
ifeq ("$(ENABLE_COMPILER_SERVER)","1")
COMPILER_SERVER_ARGS=/shared:$(COMPILER_SERVER_PIPENAME)
CSC_LOCATION=$(SERVER_CSC_LOCATION)
else
COMPILER_SERVER_ARGS:=
CSC_LOCATION=$(STANDALONE_CSC_LOCATION)
endif
USE_MCS_FLAGS = /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
USE_MBAS_FLAGS = /codepage:$(CODEPAGE) $(LOCAL_MBAS_FLAGS) $(PLATFORM_MBAS_FLAGS) $(PROFILE_MBAS_FLAGS) $(MBAS_FLAGS)
USE_MCS_FLAGS = $(COMPILER_SERVER_ARGS) /codepage:$(CODEPAGE) /nologo /noconfig /deterministic $(LOCAL_MCS_FLAGS) $(PLATFORM_MCS_FLAGS) $(PROFILE_MCS_FLAGS) $(MCS_FLAGS)
USE_MBAS_FLAGS = $(COMPILER_SERVER_ARGS) /codepage:$(CODEPAGE) $(LOCAL_MBAS_FLAGS) $(PLATFORM_MBAS_FLAGS) $(PROFILE_MBAS_FLAGS) $(MBAS_FLAGS)
USE_CFLAGS = $(LOCAL_CFLAGS) $(CFLAGS) $(CPPFLAGS)
CSCOMPILE = $(Q_MCS) $(MCS) $(USE_MCS_FLAGS)
CSC_RUNTIME_FLAGS = --aot-path=$(abspath $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)) --gc-params=nursery-size=64m
@@ -54,11 +59,9 @@ INTERNAL_CSC_LOCATION = $(CSC_LOCATION)
INTERNAL_CSC = CSC_SDK_PATH_DISABLED= $(RUNTIME) $(RUNTIME_FLAGS) $(CSC_RUNTIME_FLAGS) $(INTERNAL_CSC_LOCATION)
RESGEN = MONO_PATH="$(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/resgen.exe
STRING_REPLACER = MONO_PATH="$(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/tmp/cil-stringreplacer.exe
STRING_REPLACER = MONO_PATH="$(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/cil-stringreplacer.exe
ILASM = MONO_PATH="$(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/ilasm.exe
GENSOURCES_LIBDIR = $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)
GENSOURCES_CS = $(topdir)/build/gensources.cs
GENSOURCES_EXE = $(topdir)/build/gensources.exe
GENSOURCES = MONO_PATH="$(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(RUNTIME_FLAGS) $(topdir)/class/lib/$(BUILD_TOOLS_PROFILE)/gensources.exe
depsdir = $(topdir)/build/deps
@@ -74,9 +77,6 @@ export MKINSTALLDIRS
export BOOTSTRAP_MCS
export DESTDIR
export RESGEN
export GENSOURCES_LIBDIR
export GENSOURCES_CS
export GENSOURCES_EXE
# Get this so the platform.make platform-check rule doesn't become the
# default target
@@ -145,11 +145,11 @@ endif
# mcs/class/lib/$(PROFILE)/
ifndef TOP_LEVEL_DO
ifdef ALWAYS_AOT
ifneq ($(or $(ALWAYS_AOT_BCL), $(ALWAYS_AOT_TESTS)),)
TOP_LEVEL_DO = do-all-aot
else
TOP_LEVEL_DO = do-all
endif # ALWAYS_AOT
endif
endif # !TOP_LEVEL_DO
@@ -181,15 +181,23 @@ do-all-aot:
# be able to evaluate the .dylibs to make
ifneq ("$(wildcard $(topdir)/class/lib/$(PROFILE))","")
ifdef ALWAYS_AOT_BCL
AOT_PROFILE_ASSEMBLIES := $(sort $(patsubst .//%,%,$(filter-out %.dll.dll %.exe.dll %bare% %plaincore% %secxml% %Facades% %ilasm%,$(filter %.dll %.exe,$(wildcard $(topdir)/class/lib/$(PROFILE)/*)))))
AOT_PROFILE_TESTS := $(sort $(patsubst .//%,%,$(filter-out %.dll.dll %.exe.dll %bare% %plaincore% %secxml% %Facades% %ilasm%,$(filter %.dll %.exe,$(wildcard $(topdir)/class/lib/$(PROFILE)/tests/*)))))
AOT_PROFILE_ASSEMBLIES_OUT := $(patsubst %,%$(PLATFORM_AOT_SUFFIX),$(AOT_PROFILE_ASSEMBLIES))
AOT_PROFILE_FACADES := $(sort $(patsubst .//%,%,$(filter-out %.dll.dll %.exe.dll %bare% %plaincore% %secxml% %Facades% %ilasm%,$(filter %.dll %.exe,$(wildcard $(topdir)/class/lib/$(PROFILE)/Facades/*)))))
AOT_PROFILE_FACADES_OUT := $(patsubst %,%$(PLATFORM_AOT_SUFFIX),$(AOT_PROFILE_FACADES))
endif
ifdef ALWAYS_AOT_TESTS
AOT_PROFILE_TESTS := $(sort $(patsubst .//%,%,$(filter-out %.dll.dll %.exe.dll %bare% %plaincore% %secxml% %Facades% %ilasm%,$(filter %.dll %.exe,$(wildcard $(topdir)/class/lib/$(PROFILE)/tests/*)))))
AOT_PROFILE_TESTS_OUT := $(patsubst %,%$(PLATFORM_AOT_SUFFIX),$(AOT_PROFILE_TESTS))
endif
# This can run in parallel
.PHONY: aot-all-profile
ifdef AOT_BUILD_FLAGS
aot-all-profile: $(AOT_PROFILE_ASSEMBLIES_OUT) $(AOT_PROFILE_TESTS_OUT)
aot-all-profile: $(AOT_PROFILE_ASSEMBLIES_OUT) $(AOT_PROFILE_TESTS_OUT) $(AOT_PROFILE_FACADES_OUT)
else
aot-all-profile:
echo AOT_BUILD_FLAGS not set, skipping AOT.
@@ -197,12 +205,12 @@ endif
%.dll$(PLATFORM_AOT_SUFFIX): %.dll
@ mkdir -p $<_bitcode_tmp
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp --verbose $< > [email protected]
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp $<
@ rm -rf $<_bitcode_tmp
%.exe$(PLATFORM_AOT_SUFFIX): %.exe
@ mkdir -p $<_bitcode_tmp
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp --verbose $< > [email protected]
$(Q_AOT) MONO_PATH="$(topdir)/class/lib/$(PROFILE)" $(RUNTIME) $(RUNTIME_FLAGS) $(AOT_BUILD_FLAGS),temp-path=$<_bitcode_tmp $<
@ rm -rf $<_bitcode_tmp
endif #ifneq ("$(wildcard $(topdir)/class/lib/$(PROFILE))","")
@@ -340,7 +348,7 @@ dist-default:
## Documentation stuff
Q_MDOC =$(if $(V),,@echo "MDOC [$(PROFILE_DIRECTORY)] $(notdir $(@))";)
MDOC =$(Q_MDOC) MONO_PATH="$(topdir)/class/lib/$(DEFAULT_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(topdir)/class/lib/$(DEFAULT_PROFILE)/mdoc.exe
MDOC =$(Q_MDOC) MONO_PATH="$(topdir)/class/lib/$(PROFILE_DIRECTORY)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(topdir)/class/lib/$(PROFILE_DIRECTORY)/mdoc.exe
Q_MDOC_UP=$(if $(V),,@echo "MDOC-UP [$(PROFILE_DIRECTORY)] $(notdir $(@))";)
MDOC_UP =$(Q_MDOC_UP) MONO_PATH="$(topdir)/class/lib/$(DEFAULT_PROFILE)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(topdir)/class/lib/$(DEFAULT_PROFILE)/mdoc.exe update --delete -o Documentation/en
MDOC_UP =$(Q_MDOC_UP) MONO_PATH="$(topdir)/class/lib/$(PROFILE_DIRECTORY)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME) $(topdir)/class/lib/$(PROFILE_DIRECTORY)/mdoc.exe update --delete -o Documentation/en
+24
View File
@@ -0,0 +1,24 @@
#!/usr/bin/env bash
# usage: start-compiler-server.sh <working directory> <log path> <pipename>
# ensure that VBCS_RUNTIME and VBCS_LOCATION environment variables are set.
set -u
set -e
if [ -s "$VBCS_LOCATION" ]; then
CMD="RoslynCommandLineLogFile=$2 $VBCS_RUNTIME --gc-params=nursery-size=64m \"$VBCS_LOCATION\" -pipename:$3 &"
echo . > "$2"
echo "cd $1; bash -c \"$CMD\""
cd "$1"
bash -c "$CMD"
RESULT=$?
if [ $RESULT -eq 0 ]; then
echo Compiler server started.
else
echo Failed to start compiler server.
fi;
else
echo No compiler server found at path "$VBCS_LOCATION". Ensure that VBCS_LOCATION is set in config.make or passed as a parameter to make.
echo Use ENABLE_COMPILER_SERVER=0 to disable the use of the compiler server and continue to build.
exit 1
fi;
+88 -63
View File
@@ -23,7 +23,7 @@ test_lib_dir = $(topdir)/class/lib/$(PROFILE)/tests
test_nunit_lib = nunitlite.dll
xunit_core := xunit.core xunit.execution.dotnet xunit.abstractions xunit.assert Xunit.NetCore.Extensions
xunit_deps := System.Runtime
xunit_deps := netstandard 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)
@@ -54,7 +54,8 @@ xunit_src += $(topdir)/../mcs/class/test-helpers/RemoteExecutorTestBase.Mono.cs
endif
endif
endif
endif
endif # ($(USE_XTEST_REMOTE_EXECUTOR), YES)
xunit_class_deps :=
@@ -64,36 +65,47 @@ xunit_libs_ref += $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE)/Facades/%.dll,$
xunit_libs_dep = $(xunit_class_deps:%=$(topdir)/class/lib/$(PROFILE)/$(PARENT_PROFILE)%.dll)
xunit_libs_ref += $(xunit_libs_dep:%=-r:%)
TEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE)/%.dll,$(TEST_LIB_REFS) $(DEFAULT_REFERENCES))
TEST_LIB_REFS_ALL = $(TEST_LIB_REFS) $(DEFAULT_REFERENCES)
ifdef TARGET_NET_REFERENCE
# System*, mscorlib references come from the TARGET_NET_REFERENCE dir, others from the profile dir
TEST_LIB_REFS_MONO = $(call _FILTER_OUT,System,$(call _FILTER_OUT,mscorlib,$(TEST_LIB_REFS_ALL)))
TEST_LIB_REFS_SYSTEM = $(filter-out $(TEST_LIB_REFS_MONO),$(TEST_LIB_REFS_ALL))
TEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/../external/binary-reference-assemblies/$(TARGET_NET_REFERENCE)/%.dll,$(TEST_LIB_REFS_SYSTEM))
TEST_LIB_MCS_FLAGS += $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE_DIRECTORY)/%.dll,$(TEST_LIB_REFS_MONO))
else
TEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE_DIRECTORY)/%.dll,$(TEST_LIB_REFS_ALL))
endif
XTEST_LIB_MCS_FLAGS = $(patsubst %,-r:$(topdir)/class/lib/$(PROFILE)/%.dll,$(XTEST_LIB_REFS) $(DEFAULT_REFERENCES))
test_nunit_dep = $(test_nunit_lib:%=$(topdir)/class/lib/$(PROFILE)/$(PARENT_PROFILE)%)
test_nunit_ref = $(test_nunit_dep:%=-r:%)
tests_CLEAN_FILES += TestResult*.xml
test_sourcefile = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
test_sourcefile_base = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
ifeq ($(wildcard $(test_sourcefile)),)
test_sourcefile = $(ASSEMBLY:$(ASSEMBLY_EXT)=_test.dll.sources)
ifeq ($(wildcard $(test_sourcefile_base)),)
test_sourcefile_base = $(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
test_sourcefile_base_excludes = $(test_lib).exclude.sources
test_pdb = $(test_lib:.dll=.pdb)
test_response = $(depsdir)/$(test_lib).response
test_makefrag = $(depsdir)/$(test_lib).makefrag
test_flags = $(test_nunit_ref) $(TEST_MCS_FLAGS) $(TEST_LIB_MCS_FLAGS)
ifndef NO_BUILD
test_flags += -r:$(the_assembly)
test_assembly_dep = $(the_assembly)
endif
tests_CLEAN_FILES += $(test_lib_output) $(test_lib_output:$(ASSEMBLY_EXT)=.pdb) $(test_response) $(test_makefrag)
tests_CLEAN_FILES += $(test_lib_output) $(test_lib_output:$(ASSEMBLY_EXT)=.pdb)
xtest_sourcefile = $(PROFILE_PLATFORM)_$(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
xtest_sourcefile_excludes = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.exclude.sources)
xtest_sourcefile_base = $(PROFILE_PLATFORM)_$(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
xtest_sourcefile_base_excludes_full = $(PROFILE_PLATFORM)_$(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.exclude.sources)
xtest_sourcefile_base_excludes = $(xtest_sourcefile_base_excludes_full:_%=%)
xunit_test_lib = $(PROFILE)_$(ASSEMBLY:$(ASSEMBLY_EXT)=_xunit-test.dll)
xtest_lib_output = $(test_lib_dir)/$(xunit_test_lib)
@@ -102,16 +114,16 @@ xtest_response = $(depsdir)/$(xunit_test_lib).response
xtest_makefrag = $(depsdir)/$(xunit_test_lib).makefrag
xtest_flags = -r:$(the_assembly) $(xunit_libs_ref) $(XTEST_MCS_FLAGS) $(XTEST_LIB_MCS_FLAGS) /unsafe
ifeq ($(wildcard $(xtest_sourcefile)),)
xtest_sourcefile = $(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
ifeq ($(wildcard $(xtest_sourcefile_base)),)
xtest_sourcefile_base = $(ASSEMBLY:$(ASSEMBLY_EXT)=_xtest.dll.sources)
tests_CLEAN_FILES += $(xtest_lib_output) $(xtest_response) $(xtest_makefrag)
endif
ifndef HAVE_CS_TESTS
HAVE_CS_TESTS := $(wildcard $(test_sourcefile))
HAVE_CS_TESTS := $(wildcard $(test_sourcefile_base))
endif
HAVE_CS_XTESTS := $(wildcard $(xtest_sourcefile))
HAVE_CS_XTESTS := $(wildcard $(xtest_sourcefile_base))
endif # !NO_TEST
@@ -135,40 +147,38 @@ ifdef HAVE_CS_TESTS
test_assemblies += $(test_lib_output)
check: run-test
test-local: $(test_assemblies)
test-local: $(test_assemblies) $(test_lib_dir)/nunit-excludes.txt
run-test-local: run-test-lib
run-test-ondotnet-local: run-test-ondotnet-lib
ifdef TEST_WITH_INTERPRETER
TEST_HARNESS_EXCLUDES = -exclude=$(PLATFORM_TEST_HARNESS_EXCLUDES)$(PROFILE_TEST_HARNESS_EXCLUDES)NotWorking,NotWorkingRuntimeInterpreter,CAS
else
TEST_HARNESS_EXCLUDES = -exclude=$(PLATFORM_TEST_HARNESS_EXCLUDES)$(PROFILE_TEST_HARNESS_EXCLUDES)NotWorking,CAS
endif
TEST_HARNESS_EXCLUDES = $(PLATFORM_TEST_HARNESS_EXCLUDES) $(PROFILE_TEST_HARNESS_EXCLUDES) NotWorking CAS
TEST_HARNESS_EXCLUDES_ONDOTNET = /exclude:$(PLATFORM_TEST_HARNESS_EXCLUDES)$(PROFILE_TEST_HARNESS_EXCLUDES)NotDotNet,CAS
ifdef TEST_WITH_INTERPRETER
TEST_HARNESS_EXCLUDES += NotWorkingRuntimeInterpreter
endif
NOSHADOW_FLAG =
ifdef FIXTURE
FIXTURE_ARG = -test=MonoTests.$(FIXTURE)
FIXTURE_ARG = -test=$(FIXTURE)
endif
ifdef TESTNAME
TESTNAME_ARG = -test=MonoTests.$(TESTNAME)
TESTNAME_ARG = -test=$(TESTNAME)
endif
ifdef TEST_HARNESS_VERBOSE
LABELS_ARG = -labels
endif
ifdef ALWAYS_AOT
ifdef ALWAYS_AOT_TESTS
test-local-aot-compile: $(topdir)/build/deps/nunit-$(PROFILE).stamp $(test_assemblies)
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" MONO_REGISTRY_PATH="$(HOME)/.mono/registry" MONO_TESTS_IN_PROGRESS="yes" $(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) $(AOT_BUILD_FLAGS) $(test_assemblies)
else
test-local-aot-compile: $(topdir)/build/deps/nunit-$(PROFILE).stamp $(test_assemblies)
endif # ALWAYS_AOT
endif # ALWAYS_AOT_TESTS
ifdef COVERAGE
TEST_COVERAGE_FLAGS = -O=-aot --profile=coverage:output=$(topdir)/class/lib/$(PROFILE_DIRECTORY)/coverage_nunit_$(ASSEMBLY).xml
@@ -210,7 +220,7 @@ MKBUNDLE_EXE = $(topdir)/class/lib/$(PROFILE)/mkbundle.exe
TEST_ASSEMBLIES:=$(sort $(patsubst .//%,%,$(filter-out %.exe.static %.dll.dll %.exe.dll %bare% %plaincore% %secxml% %Facades% %ilasm%,$(filter %.dll,$(wildcard $(topdir)/class/lib/$(PROFILE)/tests/*)))))
$(MKBUNDLE_EXE): $(topdir)/tools/mkbundle/mkbundle.cs
make -C $(topdir)/tools/mkbundle
$(MAKE) -C $(topdir)/tools/mkbundle
mkbundle-all-tests:
$(Q_AOT) $(MAKE) -C $(topdir)/class do-test
@@ -229,15 +239,19 @@ endif # PLATFORM_AOT_SUFFIX
ifneq ($(wildcard $(MKBUNDLE_TEST_BIN)),)
TEST_HARNESS_EXEC=$(MKBUNDLE_TEST_BIN)
TEST_HARNESS_EXCLUDES:=$(TEST_HARNESS_EXCLUDES),StaticLinkedAotNotWorking
TEST_HARNESS_EXCLUDES:=$(TEST_HARNESS_EXCLUDES) StaticLinkedAotNotWorking
else
TEST_HARNESS_EXEC=$(TEST_RUNTIME) $(TEST_RUNTIME_FLAGS) $(TEST_COVERAGE_FLAGS) $(AOT_RUN_FLAGS) $(TEST_HARNESS)
endif
$(test_lib_dir)/nunit-excludes.txt: $(topdir)/build/tests.make | $(test_lib_dir)
@rm -f $@
@$(foreach entry,$(TEST_HARNESS_EXCLUDES),echo "$(entry)" >> $@;)
## FIXME: i18n problem in the 'sed' command below
run-test-lib: test-local test-local-aot-compile copy-nunitlite-appconfig
ok=:; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" MONO_REGISTRY_PATH="$(HOME)/.mono/registry" MONO_TESTS_IN_PROGRESS="yes" DBG_RUNTIME_ARGS="$(TEST_RUNTIME_FLAGS)" $(TEST_HARNESS_EXEC) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_FLAGS) $(TEST_HARNESS_EXCLUDES) $(LABELS_ARG) -format:nunit2 -result:TestResult-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG)|| ok=false; \
PATH="$(TEST_RUNTIME_WRAPPERS_PATH):$(PATH)" MONO_REGISTRY_PATH="$(HOME)/.mono/registry" MONO_TESTS_IN_PROGRESS="yes" DBG_RUNTIME_ARGS="$(TEST_RUNTIME_FLAGS)" $(TEST_HARNESS_EXEC) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_FLAGS) -exclude=$(subst $(space),$(comma),$(TEST_HARNESS_EXCLUDES)) $(LABELS_ARG) -format:nunit2 -result:TestResult-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG)|| ok=false; \
if [ ! -f "TestResult-$(PROFILE).xml" ]; then echo "<?xml version='1.0' encoding='utf-8'?><test-results failures='1' total='1' not-run='0' name='bcl-tests' date='$$(date +%F)' time='$$(date +%T)'><test-suite name='$(strip $(test_assemblies))' success='False' time='0'><results><test-case name='$(notdir $(strip $(test_assemblies))).crash' executed='True' success='False' time='0'><failure><message>The test runner didn't produce a test result XML, probably due to a crash of the runtime. Check the log for more details.</message><stack-trace></stack-trace></failure></test-case></results></test-suite></test-results>" > TestResult-$(PROFILE).xml; fi; \
$$ok
@@ -245,7 +259,7 @@ run-test-lib: test-local test-local-aot-compile copy-nunitlite-appconfig
run-test-ondotnet-lib: LOCAL_TEST_COMPILER_ONDOTNET_FLAGS:=-d:RUN_ONDOTNET
run-test-ondotnet-lib: test-local
ok=:; \
$(TEST_HARNESS) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_ONDOTNET_FLAGS) $(TEST_HARNESS_EXCLUDES_ONDOTNET) $(LABELS_ARG) -format:nunit2 -result:TestResult-ondotnet-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG) || ok=false; \
$(TEST_HARNESS) $(test_assemblies) $(NOSHADOW_FLAG) $(TEST_HARNESS_FLAGS) $(LOCAL_TEST_HARNESS_ONDOTNET_FLAGS) /exclude:$(subst $(space),$(comma),$(TEST_HARNESS_EXCLUDES) NotDotNet) $(LABELS_ARG) -format:nunit2 -result:TestResult-ondotnet-$(PROFILE).xml $(FIXTURE_ARG) $(TESTNAME_ARG) || ok=false; \
$$ok
@@ -254,7 +268,7 @@ endif
TEST_FILES =
ifdef HAVE_CS_TESTS
TEST_FILES += `sed -e '/^$$/d' -e 's,^../,,' -e '/^\#.*$$/d' -et -e 's,^,Test/,' $(test_sourcefile)`
TEST_FILES += `sed -e '/^$$/d' -e 's,^../,,' -e '/^\#.*$$/d' -et -e 's,^,Test/,' $(test_sourcefile_base)`
endif
ifdef HAVE_CS_TESTS
@@ -262,33 +276,31 @@ ifdef HAVE_CS_TESTS
$(test_lib_dir):
mkdir -p $@
test_library = $(ASSEMBLY:$(ASSEMBLY_EXT)=)_test$(ASSEMBLY_EXT)
test_sourcefile = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(test_library).sources
$(test_sourcefile): $(test_sourcefile_base) $(wildcard *_test.dll.sources) $(wildcard *_test.dll.exclude.sources) $(depsdir)/.stamp
$(GENSOURCES) --basedir:./Test --strict --platformsdir:$(topdir)/build "$@" "$(test_library)" "$(PROFILE_PLATFORM)" "$(PROFILE)"
test_response = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(test_library).response
$(test_response): $(test_sourcefile) $(topdir)/build/tests.make $(depsdir)/.stamp
$(PLATFORM_CHANGE_SEPARATOR_CMD) <$(test_sourcefile) >$@
test_makefrag = $(depsdir)/$(PROFILE_PLATFORM)_$(PROFILE)_$(test_library).makefrag
$(test_makefrag): $(test_sourcefile) $(topdir)/build/tests.make $(depsdir)/.stamp
@echo Creating $@ ...
@sed 's,^,$(build_lib): ,' $< >$@
@if test ! -f $(test_sourcefile).makefrag; then :; else \
cat $(test_sourcefile).makefrag >> $@ ; \
echo '$@: $(test_sourcefile).makefrag' >> $@; \
echo '$(test_sourcefile).makefrag:' >> $@; fi
$(test_lib_output): $(test_assembly_dep) $(test_response) $(test_nunit_dep) $(test_lib_output).nunitlite.config | $(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
tests_CLEAN_FILES += $(test_sourcefile) $(test_response) $(test_makefrag)
ifneq "x" "x$(PROFILE_RUNTIME)"
GENSOURCES_RUNTIME=$(PROFILE_RUNTIME)
else
ifneq "x" "x$(TEST_RUNTIME)"
GENSOURCES_RUNTIME=$(TEST_RUNTIME)
else
GENSOURCES_RUNTIME=MONO_PATH="$(GENSOURCES_LIBDIR)$(PLATFORM_PATH_SEPARATOR)$$MONO_PATH" $(RUNTIME)
endif
endif
# This handles .excludes/.sources pairs, as well as resolving the
# includes that occur in .sources files
$(test_response_preprocessed): $(test_sourcefile) $(wildcard $(test_sourcefile_excludes)) $(GENSOURCES_CS)
$(GENSOURCES_RUNTIME) --debug $(GENSOURCES_EXE) --basedir:./Test --strict "$@" "$(test_sourcefile)" "$(test_sourcefile_excludes)"
$(test_response): $(test_response_preprocessed)
# @echo Creating $@ ...
@sed -e '/^$$/d' -e 's,^,Test/,' $(test_response_preprocessed) | $(PLATFORM_CHANGE_SEPARATOR_CMD) >$@
$(test_makefrag): $(test_response)
# @echo Creating $@ ...
@sed 's,^,$(test_lib_output): ,' $< >$@
-include $(test_makefrag)
@@ -304,11 +316,17 @@ XTEST_HARNESS_PATH := $(topdir)/../external/xunit-binaries
XTEST_HARNESS = $(XTEST_HARNESS_PATH)/xunit.console.exe
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
XTEST_NOTRAITS := category=failing category=nonmonotests Benchmark=true
ifndef OUTER_LOOP
XTEST_NOTRAITS += category=outerloop
endif
# 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
# https://github.com/dotnet/buildtools/blob/master/src/xunit.netcore.extensions/Discoverers/PlatformSpecificDiscoverer.cs
XTEST_TRAIT_PLATFORM := -notrait category=non$(XTEST_PLATFORM)tests
XTEST_NOTRAITS += category=non$(XTEST_PLATFORM)tests
TEST_MONO_PATH := $(TEST_MONO_PATH)$(PLATFORM_PATH_SEPARATOR)$(XTEST_HARNESS_PATH)
@@ -325,17 +343,24 @@ XTEST_COVERAGE_FLAGS = -O=-aot --profile=coverage:output=$(topdir)/class/lib/$(P
endif
check: run-xunit-test-local
xunit-test-local: $(xtest_lib_output)
xunit-test-local: $(xtest_lib_output) $(test_lib_dir)/xunit-excludes.txt $(test_lib_dir)/Xunit.NetCore.Extensions.dll $(test_lib_dir)/xunit.execution.dotnet.dll
run-xunit-test-local: run-xunit-test-lib
# cp -rf is a HACK for xunit runner to require xunit.execution.dOTNET.dll file in local folder on .net only
$(test_lib_dir)/xunit-excludes.txt: $(topdir)/build/tests.make | $(test_lib_dir)
@rm -f $@
$(foreach entry,$(XTEST_NOTRAITS),echo "$(entry)" >> $@;)
$(test_lib_dir)/Xunit.NetCore.Extensions.dll: $(topdir)/build/tests.make $(topdir)/../external/xunit-binaries/Xunit.NetCore.Extensions.dll | $(test_lib_dir)
@cp -f $(topdir)/../external/xunit-binaries/Xunit.NetCore.Extensions.dll $@
$(test_lib_dir)/xunit.execution.dotnet.dll: $(topdir)/build/tests.make $(topdir)/../external/xunit-binaries/xunit.execution.dotnet.dll | $(test_lib_dir)
@cp -f $(topdir)/../external/xunit-binaries/xunit.execution.dotnet.dll $@
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_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; \
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) -notrait $(subst $(space), -notrait ,$(XTEST_NOTRAITS)) || 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 $(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 | $(test_lib_dir)
@@ -348,8 +373,8 @@ xtest_response_preprocessed = $(xtest_response)_preprocessed
# This handles .excludes/.sources pairs, as well as resolving the
# includes that occur in .sources files
$(xtest_response): $(xtest_sourcefile) $(wildcard *xtest.dll.sources) $(wildcard $(xtest_sourcefile_excludes)) $(GENSOURCES_CS)
$(GENSOURCES_RUNTIME) --debug $(GENSOURCES_EXE) --strict "$@" "$(xtest_sourcefile)" "$(xtest_sourcefile_excludes)"
$(xtest_response): $(xtest_sourcefile_base) $(wildcard *xtest.dll.sources) $(wildcard $(xtest_sourcefile_base_excludes))
$(GENSOURCES) --strict --platformsdir:$(topdir)/build "$@" "$(xtest_sourcefile_base)" "$(xtest_sourcefile_base_excludes)"
$(xtest_makefrag): $(xtest_response)
@echo Creating $@ ...
+74 -74
View File
@@ -1,75 +1,75 @@
<?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>{2CFDD4F5-4B13-4FF4-A421-0361F2FC825F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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>Accessibility</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="Accessibility\IAccessible.cs" />
<Compile Include="Accessibility\IAccessibleHandler.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{2CFDD4F5-4B13-4FF4-A421-0361F2FC825F}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Accessibility</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="Accessibility\IAccessible.cs" />
<Compile Include="Accessibility\IAccessibleHandler.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,131 +1,131 @@
<?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>{79381DFE-F13A-4A37-9A89-6640702D46E3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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>Commons.Xml.Relaxng</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../mono.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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 Condition=" '$(Platform)' == 'net_4_x' ">
<Compile Include="Commons.Xml.Relaxng.Rnc\RncParser.cs" />
</ItemGroup>
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlBuiltInValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlCompileContext.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlConfig.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlException.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlFilteredXmlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlRelaxngSupport.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlSimplified.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlStructures.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidatingReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidator.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlXsdSupport.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpContentType.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpNameClasses.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpObjects.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpPatterns.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\Util.cs" />
<Compile Include="Commons.Xml.Relaxng.Inference\RelaxngInference.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncTokenizer.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncWriter.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\XmlChar.cs" />
<Compile Include="Commons.Xml.Relaxng\Misc.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatype.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatypeProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDefaultDatatypes.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngException.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngGrammar.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngMergedProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngNameClass.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPattern.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPatternType.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngReader.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngValidatingReader.cs" />
<Compile Include="Commons.Xml.Relaxng\XsdDatatypeProvider.cs" />
<Compile Include="Commons.Xml\XmlDefaultReader.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
<ProjectReference Include="$(SolutionDir)\mcs\jay\jay.vcxproj">
<Name>jay</Name>
<Project>{5d485d32-3b9f-4287-ab24-c8da5b89f537}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../System.XML/System.Xml.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<EmbeddedResource Include="resources/relaxng.rng">
<LogicalName>relaxng.rng</LogicalName>
</EmbeddedResource>
</ItemGroup>
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay.exe -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
</PropertyGroup>
<?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>{79381DFE-F13A-4A37-9A89-6640702D46E3}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Commons.Xml.Relaxng</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../mono.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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 Condition=" '$(Platform)' == 'net_4_x' ">
<Compile Include="Commons.Xml.Relaxng.Rnc\RncParser.cs" />
</ItemGroup>
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlBuiltInValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlCompileContext.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlConfig.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlException.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlFilteredXmlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlRelaxngSupport.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlSimplified.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlStructures.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidatingReader.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidationProvider.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlValidator.cs" />
<Compile Include="Commons.Xml.Nvdl\NvdlXsdSupport.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpContentType.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpNameClasses.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpObjects.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\RdpPatterns.cs" />
<Compile Include="Commons.Xml.Relaxng.Derivative\Util.cs" />
<Compile Include="Commons.Xml.Relaxng.Inference\RelaxngInference.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncTokenizer.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\RncWriter.cs" />
<Compile Include="Commons.Xml.Relaxng.Rnc\XmlChar.cs" />
<Compile Include="Commons.Xml.Relaxng\Misc.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatype.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDatatypeProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngDefaultDatatypes.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngException.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngGrammar.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngMergedProvider.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngNameClass.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPattern.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngPatternType.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngReader.cs" />
<Compile Include="Commons.Xml.Relaxng\RelaxngValidatingReader.cs" />
<Compile Include="Commons.Xml.Relaxng\XsdDatatypeProvider.cs" />
<Compile Include="Commons.Xml\XmlDefaultReader.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
<ProjectReference Include="$(SolutionDir)\mcs\jay\jay.vcxproj">
<Name>jay</Name>
<Project>{5d485d32-3b9f-4287-ab24-c8da5b89f537}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../System.XML/System.Xml.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<EmbeddedResource Include="resources/relaxng.rng">
<LogicalName>relaxng.rng</LogicalName>
</EmbeddedResource>
</ItemGroup>
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<PropertyGroup>
<PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
<PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">$(ProjectDir)\..\..\jay\jay.exe -ct &lt; $(ProjectDir)\..\..\jay\skeleton.cs $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.jay &gt; $(ProjectDir)\Commons.Xml.Relaxng.Rnc\RncParser.cs</PreBuildEvent>
</PropertyGroup>
</Project>
+78 -78
View File
@@ -1,79 +1,79 @@
<?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>{546B21E5-FB99-44A5-8721-2D672FBCD7FF}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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>cscompmgd</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Microsoft.CSharp\Compiler.cs" />
<Compile Include="Microsoft.CSharp\CompilerError.cs" />
<Compile Include="Microsoft.CSharp\ErrorLevel.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{546B21E5-FB99-44A5-8721-2D672FBCD7FF}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>cscompmgd</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="Microsoft.CSharp\Compiler.cs" />
<Compile Include="Microsoft.CSharp\CompilerError.cs" />
<Compile Include="Microsoft.CSharp\ErrorLevel.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,80 +1,80 @@
<?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>{FC00125C-BEA1-4A1E-A463-6070352602CD}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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>CustomMarshalers</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumerableToDispatchMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumeratorToEnumVariantMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\ExpandoToDispatchExMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\TypeToTypeInfoMarshaler.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{FC00125C-BEA1-4A1E-A463-6070352602CD}</ProjectGuid>
<OutputType>Library</OutputType>
<NoWarn>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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>CustomMarshalers</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../class/lib/net_4_x-$(HostPlatform)</OutputPath>
<IntermediateOutputPath>./../../class/obj/$(AssemblyName)-net_4_x-$(HostPlatform)</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\build\common\Consts.cs" />
<Compile Include="..\..\build\common\Locale.cs" />
<Compile Include="..\..\build\common\MonoTODOAttribute.cs" />
<Compile Include="Assembly\AssemblyInfo.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumerableToDispatchMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\EnumeratorToEnumVariantMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\ExpandoToDispatchExMarshaler.cs" />
<Compile Include="System.Runtime.InteropServices.CustomMarshalers\TypeToTypeInfoMarshaler.cs" />
<ProjectReference Include="$(SolutionDir)\msvc\scripts\genconsts.csproj">
<Name>genconsts</Name>
<Project>{702AE2C0-71DD-4112-9A06-E4FABCA59986}</Project>
<ReferenceOutputAssembly>false</ReferenceOutputAssembly>
<CopyToOutputDirectory>Never</CopyToOutputDirectory>
<Private>false</Private>
</ProjectReference>
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<!-- @COMMON_PROJECT_REFERENCES@ -->
<ItemGroup Condition=" '$(Platform)' == 'net_4_x' ">
<ProjectReference Include="../System/System.csproj" />
<ProjectReference Include="../corlib/corlib.csproj" />
</ItemGroup>
<!-- @ALL_REFERENCES@ -->
<!-- @ALL_RESOURCES@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
+2 -2
View File
@@ -39,8 +39,8 @@ doc-update-recursive:
System System.Core System.ComponentModel.DataAnnotations System.Numerics System.Numerics.Vectors System.Runtime.Serialization System.Transactions System.Xml \
System.ComponentModel.Composition System.ServiceModel System.Xml.Linq System.Data System.IO.Compression.FileSystem System.Runtime.InteropServices.RuntimeInformation \
System.ServiceProcess System.Security System.Net.Http.WebRequest System.Net.Http System.ServiceProcess System.IO.Compression System.IdentityModel \
System.Web.Services:
System.ServiceProcess System.Security System.Net.Http.WebRequest System.Net.Http System.ServiceProcess System.IO.Compression System.IdentityModel System.Web \
Facades/System.Drawing.Primitives Facades/System.Drawing.Common System.Drawing System.Web.Services:
all-local-aot:
@@ -1,128 +1,139 @@
<?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>{FADE0AB0-B7B9-4909-B4AD-38ABE84E183A}</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>Microsoft.Win32.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{FADE0AB0-B7B9-4909-B4AD-38ABE84E183A}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,129 +1,140 @@
<?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>{ECD1D1FD-CEBA-4282-989B-EE031A809F2C}</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>Microsoft.Win32.Registry.AccessControl</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\..\..\external\corefx\src\Microsoft.Win32.Registry.AccessControl\src\Microsoft\Win32\RegistryAclExtensions.cs" />
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{ECD1D1FD-CEBA-4282-989B-EE031A809F2C}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Registry.AccessControl</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="..\..\..\..\external\corefx\src\Microsoft.Win32.Registry.AccessControl\src\Microsoft\Win32\RegistryAclExtensions.cs" />
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{21811072-CC82-465D-B8D7-DA89A63024F9}</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>Microsoft.Win32.Registry</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{21811072-CC82-465D-B8D7-DA89A63024F9}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>Microsoft.Win32.Registry</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{E21E6C69-5A3D-44A3-BCB1-CDE08786CB41}</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.AppContext</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{E21E6C69-5A3D-44A3-BCB1-CDE08786CB41}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.AppContext</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,117 +1,128 @@
<?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>{CA080440-700C-46F4-B8F9-56D2507909D3}</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>
<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 -->
<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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{CA080440-700C-46F4-B8F9-56D2507909D3}</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'))">macos</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>
<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 -->
<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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{DE0D7286-1F09-4ACC-BC43-75342349FFC1}</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.Collections.Concurrent</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{DE0D7286-1F09-4ACC-BC43-75342349FFC1}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.Concurrent</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{42696DB3-E1FA-4C6E-BB9B-8930CD563933}</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.Collections.NonGeneric</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{42696DB3-E1FA-4C6E-BB9B-8930CD563933}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.NonGeneric</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{C5EC0603-74A8-450A-9EE2-AEBCC964134E}</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.Collections.Specialized</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{C5EC0603-74A8-450A-9EE2-AEBCC964134E}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections.Specialized</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,129 +1,140 @@
<?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>{758C73D3-F04B-40BD-B55B-057F529053CA}</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.Collections</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Core/System.Core.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{758C73D3-F04B-40BD-B55B-057F529053CA}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.Collections</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../System.Core/System.Core.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{FDD583A9-F7AB-49E2-8B0C-B3B6C24EC3C1}</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.ComponentModel.Annotations</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System.ComponentModel.DataAnnotations/System.ComponentModel.DataAnnotations.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{FDD583A9-F7AB-49E2-8B0C-B3B6C24EC3C1}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.Annotations</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System.ComponentModel.DataAnnotations/System.ComponentModel.DataAnnotations.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{71D3A7F4-7774-4421-9DF1-FFB719F0DDA7}</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.ComponentModel.EventBasedAsync</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{71D3A7F4-7774-4421-9DF1-FFB719F0DDA7}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.EventBasedAsync</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -1,128 +1,139 @@
<?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>{A2DA9A58-AE3F-41A4-8C1F-55E65244EB1B}</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.ComponentModel.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{A2DA9A58-AE3F-41A4-8C1F-55E65244EB1B}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.Primitives</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -33,6 +33,7 @@
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.IComponent))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.IContainer))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.ISite))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.ISupportInitialize))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.ImmutableObjectAttribute))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.InitializationEventAttribute))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.LocalizableAttribute))]
@@ -1,128 +1,139 @@
<?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>{4C5EAC63-07DF-41DF-8CF5-40FDA68845D9}</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.ComponentModel.TypeConverter</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{4C5EAC63-07DF-41DF-8CF5-40FDA68845D9}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel.TypeConverter</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
@@ -76,6 +76,8 @@
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.UInt16Converter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.UInt32Converter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.UInt64Converter))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.ComponentModel.Container))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.UriTypeConverter))]
@@ -1,128 +1,139 @@
<?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>{BEFF31D8-EA73-46C1-BD18-DF3952122BCA}</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.ComponentModel</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
<?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>{BEFF31D8-EA73-46C1-BD18-DF3952122BCA}</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'))">macos</HostPlatform>
<HostPlatform Condition=" '$(HostPlatform)' == '' and '$(OS)' == 'Unix'">linux</HostPlatform>
<GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
<NoStdLib>True</NoStdLib>
<NoConfig>True</NoConfig>
<AssemblyName>System.ComponentModel</AssemblyName>
<TargetFrameworkVersion>v4.6.2</TargetFrameworkVersion>
<SignAssembly>true</SignAssembly>
<DelaySign>true</DelaySign>
<AssemblyOriginatorKeyFile>../../msfinal.pub</AssemblyOriginatorKeyFile>
</PropertyGroup>
<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 -->
<AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
</PropertyGroup>
<PropertyGroup Condition=" '$(Platform)' == 'net_4_x' ">
<OutputPath>./../../../class/lib/net_4_x-$(HostPlatform)/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>NET_4_0;NET_4_5;NET_4_6;MONO;WIN_PLATFORM</DefineConstants>
</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_hybrid' ">
<OutputPath>./../../../class/lib/testing_aot_hybrid/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</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)' == 'xammac_net_4_5' ">
<OutputPath>./../../../class/lib/xammac_net_4_5/Facades</OutputPath>
<IntermediateOutputPath>./../../../class/obj/$(AssemblyName)-Facades</IntermediateOutputPath>
<DefineConstants>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</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" />
<!-- @BUILT_SOURCES@ -->
<!--Common files-->
<ItemGroup>
<Compile Include="AssemblyInfo.cs" />
<Compile Include="TypeForwarders.cs" />
</ItemGroup>
<!--End of common files-->
<!-- @ALL_SOURCES@ -->
<ItemGroup>
<ProjectReference Include="../../System/System.csproj" />
<ProjectReference Include="../../corlib/corlib.csproj" />
</ItemGroup>
<ItemGroup Condition=" '$(Platform)' == 'testing_aot_hybrid' ">
<Reference Include="nunitlite">
<HintPath>..\lib\testing_aot_hybrid\nunitlite.dll</HintPath>
<Private>False</Private>
</Reference>
</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@ -->
<PropertyGroup>
<!-- Force the pre-build event to run after references have been resolved. The default
behavior is to run them before resolving references, which can cause things like
culevel.exe to be used before they have been built. -->
<PreBuildEventDependsOn>ResolveReferences</PreBuildEventDependsOn>
</PropertyGroup>
</Project>
Loaded 100 of 4820 files, more files were not shown because too many files have changed in this diff. Show more