Header names should be compared binary but not linguistic.
the terms of the MIT X11, this means that this code can be
used for any purposes by anyone.
-** mono/metadata/sgen*: Mono's Copying Collector
-
- This new garbage collector is licensed under the terms of
- the MIT X11 license, in hopes that the GC could be reused
- by third party projects, follows the same spirit than the
- Boehm GC.
-
** mono/arch/*/XXX-codegen.h
This are C macros that are useful when generating native
AC_CHECK_FUNCS(GetProcessId)
AC_CHECK_DECLS(InterlockedExchange64, [], [], [[#include <windows.h>]])
AC_CHECK_DECLS(InterlockedCompareExchange64, [], [], [[#include <windows.h>]])
+ AC_CHECK_DECLS(InterlockedDecrement64, [], [], [[#include <windows.h>]])
AC_CHECK_DECLS(InterlockedIncrement64, [], [], [[#include <windows.h>]])
AC_CHECK_DECLS(InterlockedAdd, [], [], [[#include <windows.h>]])
AC_CHECK_DECLS(InterlockedAdd64, [], [], [[#include <windows.h>]])
gchar*
g_win32_getlocale(void)
{
- /* FIXME: Use GetThreadLocale
- * and convert LCID to standard
- * string form, "en_US" */
- return strdup ("en_US");
+ LCID lcid = GetThreadLocale();
+ gchar buf[19];
+ gint ccBuf = GetLocaleInfo(lcid, LOCALE_SISO639LANGNAME, buf, 9);
+ buf[ccBuf - 1] = '-';
+ ccBuf += GetLocaleInfo(lcid, LOCALE_SISO3166CTRYNAME, buf + ccBuf, 9);
+ return strdup(buf);
}
gboolean
thisdir = class/Facades
-monotouch_SUBDIRS = System.Collections.Concurrent System.Collections System.ComponentModel.Annotations System.ComponentModel.EventBasedAsync System.ComponentModel System.Diagnostics.Contracts System.Diagnostics.Debug System.Diagnostics.Tools System.Globalization System.IO System.Linq.Expressions System.Linq.Parallel System.Linq.Queryable System.Linq System.Net.NetworkInformation System.Net.Primitives System.Net.Requests System.ObjectModel System.Reflection.Extensions System.Reflection.Primitives System.Reflection System.Resources.ResourceManager System.Runtime.Extensions System.Runtime.InteropServices System.Runtime.Numerics System.Runtime.Serialization.Json System.Runtime.Serialization.Primitives System.Runtime.Serialization.Xml System.Runtime System.Security.Principal System.ServiceModel.Http System.ServiceModel.Primitives System.Text.Encoding.Extensions System.Text.Encoding System.Text.RegularExpressions System.Threading.Tasks.Parallel System.Threading.Tasks System.Threading System.Xml.ReaderWriter System.Xml.XDocument System.Xml.XmlSerializer
+monotouch_SUBDIRS = System.Collections.Concurrent System.Collections System.ComponentModel.Annotations System.ComponentModel.EventBasedAsync System.ComponentModel \
+ System.Diagnostics.Contracts System.Diagnostics.Debug System.Diagnostics.Tools System.Dynamic.Runtime System.Globalization System.IO System.Linq.Expressions \
+ System.Linq.Parallel System.Linq.Queryable System.Linq System.Net.NetworkInformation System.Net.Primitives System.Net.Requests System.ObjectModel \
+ System.Reflection.Extensions System.Reflection.Primitives System.Reflection System.Resources.ResourceManager System.Runtime.Extensions \
+ System.Runtime.InteropServices System.Runtime.InteropServices.WindowsRuntime System.Runtime.Numerics System.Runtime.Serialization.Json \
+ System.Runtime.Serialization.Primitives System.Runtime.Serialization.Xml System.Runtime System.Security.Principal System.ServiceModel.Http \
+ System.ServiceModel.Primitives System.Text.Encoding.Extensions System.Text.Encoding System.Text.RegularExpressions System.Threading.Tasks.Parallel \
+ System.Threading.Tasks System.Threading System.Xml.ReaderWriter System.Xml.XDocument System.Xml.XmlSerializer
mobile_static_SUBDIRS = $(monotouch_SUBDIRS)
-net_4_5_SUBDIRS = $(monotouch_SUBDIRS) System.Dynamic.Runtime System.Reflection.Emit.ILGeneration System.Reflection.Emit.Lightweight System.Reflection.Emit
+net_4_5_SUBDIRS = $(monotouch_SUBDIRS) System.Reflection.Emit.ILGeneration System.Reflection.Emit.Lightweight System.Reflection.Emit
monodroid_SUBDIRS = $(net_4_5_SUBDIRS)
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
-
+#if !FULL_AOT_RUNTIME
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Dynamic.BinaryOperationBinder))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Dynamic.BindingRestrictions))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Dynamic.CallInfo))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.CallSiteBinder))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.CallSiteHelpers))]
[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.DynamicAttribute))]
+#endif
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.CompilerServices.ConditionalWeakTable<,>))]
--- /dev/null
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+[assembly: AssemblyTitle ("System.Runtime.InteropServices.WindowsRuntime.dll")]
+[assembly: AssemblyDescription ("System.Runtime.InteropServices.WindowsRuntime.dll")]
+[assembly: AssemblyDefaultAlias ("System.Runtime.InteropServices.WindowsRuntime.dll")]
+[assembly: AssemblyCompany ("Xamarin, Inc.")]
+[assembly: AssemblyProduct ("Mono Common Language Infrastructure")]
+[assembly: AssemblyCopyright ("Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)")]
+[assembly: AssemblyVersion ("4.0.0.0")]
+[assembly: AssemblyInformationalVersion ("4.0.0.0")]
+[assembly: AssemblyFileVersion ("4.0.0.0")]
+[assembly: AssemblyDelaySign (true)]
+[assembly: AssemblyKeyFile ("../../msfinal.pub")]
+
+[assembly: ReferenceAssembly]
+
+
--- /dev/null
+MCS_BUILD_DIR = ../../../build
+
+thisdir = class/Facades/System.Runtime.InteropServices.WindowsRuntime
+SUBDIRS =
+include $(MCS_BUILD_DIR)/rules.make
+
+LIBRARY_SUBDIR = Facades
+LIBRARY_INSTALL_DIR = $(mono_libdir)/mono/$(FRAMEWORK_VERSION)/Facades
+
+LIBRARY = System.Runtime.InteropServices.WindowsRuntime.dll
+
+KEY_FILE = ../../msfinal.pub
+SIGN_FLAGS = /delaysign /keyfile:$(KEY_FILE) /nowarn:1616,1699
+LIB_MCS_FLAGS = $(SIGN_FLAGS) /r:mscorlib
+
+PLATFORM_DEBUG_FLAGS =
+
+NO_TEST = yes
+
+include $(MCS_BUILD_DIR)/library.make
+
+
--- /dev/null
+TypeForwarders.cs
+AssemblyInfo.cs
+
--- /dev/null
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+//
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.DefaultInterfaceAttribute))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationToken))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.EventRegistrationTokenTable<>))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.IActivationFactory))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.InterfaceImplementedInVersionAttribute))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.ReadOnlyArrayAttribute))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.ReturnValueNameAttribute))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal))]
+[assembly: System.Runtime.CompilerServices.TypeForwardedToAttribute(typeof(System.Runtime.InteropServices.WindowsRuntime.WriteOnlyArrayAttribute))]
Assert.AreEqual ("1+", sres, "The result should have been the input string, since we have a partial input");
}
+ [Test]
+ public void GotoWithUnreachableStatement ()
+ {
+ Evaluator.Run ("using System;");
+
+ string code = "var x = new Action(() => {" +
+ "Console.WriteLine(\"beforeGoto\");" +
+ "goto L;" +
+ "L:" +
+ "Console.WriteLine(\"afterGoto\");" +
+ "});";
+
+ Assert.IsTrue (Evaluator.Run (code), "#1");
+ Assert.IsTrue (Evaluator.Run ("x();"), "#2");
+ }
+
#if NET_4_0
[Test]
public void DynamicStatement ()
async_output.Close ();
if (async_error != null)
async_error.Close ();
+
+ if (input_stream != null) {
+ input_stream.Close();
+ input_stream = null;
+ }
+
+ if (output_stream != null) {
+ output_stream.Close();
+ output_stream = null;
+ }
+
+ if (error_stream != null) {
+ error_stream.Close();
+ error_stream = null;
+ }
}
}
Process_free_internal(process_handle);
process_handle=IntPtr.Zero;
}
-
- if (input_stream != null) {
- input_stream.Close();
- input_stream = null;
- }
-
- if (output_stream != null) {
- output_stream.Close();
- output_stream = null;
- }
-
- if (error_stream != null) {
- error_stream.Close();
- error_stream = null;
- }
}
}
base.Dispose (disposing);
using System.Configuration;
using System.Globalization;
using System.IO;
+using System.Net;
using System.Net.Cache;
using System.Net.Sockets;
using System.Runtime.Remoting.Messaging;
return result.Response;
}
+
+#if NET_3_5
+ public Stream EndGetRequestStream (IAsyncResult asyncResult, out TransportContext transportContext)
+ {
+ transportContext = null;
+ return EndGetRequestStream (asyncResult);
+ }
+#endif
public override WebResponse GetResponse()
{
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
-#if NET_4_0
+#if NET_3_5
using System.Security.Authentication.ExtendedProtection;
{
[DebuggerDisplay ("Count={Count}")]
[DebuggerTypeProxy (typeof (CollectionDebuggerView<,>))]
+ [Serializable]
public class ConcurrentDictionary<TKey, TValue> : IDictionary<TKey, TValue>,
ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>,
IDictionary, ICollection, IEnumerable
--- /dev/null
+#if NET_4_5
+//
+// DefaultInterfaceAttribute.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [AttributeUsageAttribute(AttributeTargets.Class|AttributeTargets.Interface, AllowMultiple = false, Inherited = false)]
+ public sealed class DefaultInterfaceAttribute : Attribute
+ {
+ public Type DefaultInterface {
+ get;
+ private set;
+ }
+
+ public DefaultInterfaceAttribute (Type defaultInterface)
+ {
+ DefaultInterface = defaultInterface;
+ }
+ }
+}
+#endif
--- /dev/null
+#if NET_4_5
+//
+// DesignerNamespaceResolveEventArgs.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Collections.ObjectModel;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [ComVisibleAttribute(false)]
+ public class DesignerNamespaceResolveEventArgs : EventArgs
+ {
+ public DesignerNamespaceResolveEventArgs (string namespaceName)
+ {
+ NamespaceName = namespaceName;
+ ResolvedAssemblyFiles = new Collection<string> ();
+ }
+
+ public string NamespaceName {
+ get;
+ private set;
+ }
+
+ public Collection<string> ResolvedAssemblyFiles {
+ get;
+ private set;
+ }
+ }
+}
+#endif
--- /dev/null
+#if NET_4_5
+//
+// EventRegistrationToken.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ public struct EventRegistrationToken
+ {
+#pragma warning disable 0649
+ long value;
+#pragma warning restore 0649
+
+ public static bool operator == (EventRegistrationToken left, EventRegistrationToken right)
+ {
+ return left.value == right.value;
+ }
+
+ public static bool operator != (EventRegistrationToken left, EventRegistrationToken right)
+ {
+ return left.value != right.value;
+ }
+
+ public override bool Equals (object obj)
+ {
+ return ((EventRegistrationToken)obj).value == value;
+ }
+
+ public override int GetHashCode ()
+ {
+ return unchecked ((int)value);
+ }
+ }
+}
+#endif
--- /dev/null
+#if NET_4_5
+//
+// EventRegistrationTokenTable.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [MonoTODO]
+ public sealed class EventRegistrationTokenTable<T>
+ where T : class
+ {
+ public EventRegistrationTokenTable ()
+ {
+ throw new NotImplementedException ();
+ }
+
+ public T InvocationList {
+ get { throw new NotImplementedException (); }
+ set { throw new NotImplementedException (); }
+ }
+
+ public EventRegistrationToken AddEventHandler (T handler)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static EventRegistrationTokenTable<T> GetOrCreateEventRegistrationTokenTable(ref EventRegistrationTokenTable<T> refEventTable)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public void RemoveEventHandler (T handler)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public void RemoveEventHandler (EventRegistrationToken token)
+ {
+ throw new NotImplementedException ();
+ }
+ }
+}
+#endif
+
--- /dev/null
+#if NET_4_5
+//
+// IActivationFactory.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [Guid("00000035-0000-0000-C000-000000000046")]
+ public interface IActivationFactory
+ {
+ object ActivateInstance ();
+ }
+}
+#endif
--- /dev/null
+#if NET_4_5
+//
+// InterfaceImplementedInVersionAttribute.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [AttributeUsageAttribute(AttributeTargets.Class|AttributeTargets.Interface, AllowMultiple = false, Inherited = false)]
+ public sealed class InterfaceImplementedInVersionAttribute : Attribute
+ {
+ public InterfaceImplementedInVersionAttribute (Type interfaceType, byte majorVersion, byte minorVersion,
+ byte buildVersion, byte revisionVersion)
+ {
+ InterfaceType = interfaceType;
+ MajorVersion = majorVersion;
+ MinorVersion = minorVersion;
+ BuildVersion = buildVersion;
+ RevisionVersion = revisionVersion;
+ }
+
+ public byte BuildVersion {
+ get;
+ private set;
+ }
+
+ public Type InterfaceType {
+ get;
+ private set;
+ }
+
+ public byte MajorVersion {
+ get;
+ private set;
+ }
+
+ public byte MinorVersion {
+ get;
+ private set;
+ }
+
+ public byte RevisionVersion {
+ get;
+ private set;
+ }
+ }
+}
+#endif
--- /dev/null
+#if NET_4_5
+//
+// NamespaceResolveEventArgs.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Reflection;
+using System.Collections.ObjectModel;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [ComVisibleAttribute(false)]
+ public class NamespaceResolveEventArgs : EventArgs
+ {
+ public NamespaceResolveEventArgs (string namespaceName, Assembly requestingAssembly)
+ {
+ NamespaceName = namespaceName;
+ RequestingAssembly = requestingAssembly;
+ ResolvedAssemblies = new Collection<Assembly> ();
+ }
+
+ public string NamespaceName {
+ get;
+ private set;
+ }
+
+ public Assembly RequestingAssembly {
+ get;
+ private set;
+ }
+
+ public Collection<Assembly> ResolvedAssemblies {
+ get;
+ private set;
+ }
+ }
+}
+#endif
--- /dev/null
+#if NET_4_5
+//
+// ReadOnlyArrayAttribute.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [AttributeUsageAttribute(AttributeTargets.Parameter, Inherited = false, AllowMultiple = false)]
+ public sealed class ReadOnlyArrayAttribute : Attribute
+ {
+ }
+}
+#endif
--- /dev/null
+//
+// ReturnValueNameAttribute.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [AttributeUsageAttribute(AttributeTargets.Delegate|AttributeTargets.ReturnValue, AllowMultiple = false, Inherited = false)]
+ public sealed class ReturnValueNameAttribute : Attribute
+ {
+ public ReturnValueNameAttribute (string name)
+ {
+ Name = name;
+ }
+
+ public string Name {
+ get;
+ private set;
+ }
+ }
+}
--- /dev/null
+#if NET_4_5
+//
+// WindowsRuntimeMarshal.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [MonoTODO]
+ public static class WindowsRuntimeMarshal
+ {
+ public static void AddEventHandler<T> ( Func<T, EventRegistrationToken> addMethod, Action<EventRegistrationToken> removeMethod, T handler)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static void FreeHString (IntPtr ptr)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static IActivationFactory GetActivationFactory (Type type)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static string PtrToStringHString (IntPtr ptr)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static void RemoveAllEventHandlers(Action<EventRegistrationToken> removeMethod)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static void RemoveEventHandler<T> (Action<EventRegistrationToken> removeMethod, T handler)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static IntPtr StringToHString (string s)
+ {
+ throw new NotImplementedException ();
+ }
+ }
+}
+#endif
+
--- /dev/null
+#if NET_4_5
+//
+// WindowsRuntimeMetadata.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [MonoTODO]
+ public static class WindowsRuntimeMetadata
+ {
+ public static IEnumerable<string> ResolveNamespace (string namespaceName, IEnumerable<string> packageGraphFilePaths)
+ {
+ throw new NotImplementedException ();
+ }
+
+ public static IEnumerable<string> ResolveNamespace (string namespaceName, string windowsSdkFilePath, IEnumerable<string> packageGraphFilePaths)
+ {
+ throw new NotImplementedException ();
+ }
+
+#pragma warning disable 0067
+ public static event EventHandler<DesignerNamespaceResolveEventArgs> DesignerNamespaceResolve;
+ public static event EventHandler<NamespaceResolveEventArgs> ReflectionOnlyNamespaceResolve;
+#pragma warning restore 0067
+ }
+}
+#endif
+
--- /dev/null
+#if NET_4_5
+//
+// WriteOnlyArrayAttribute.cs
+//
+// Author:
+// Martin Baulig <martin.baulig@xamarin.com>
+//
+// Copyright (c) 2013 Xamarin Inc. (http://www.xamarin.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+using System;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices.WindowsRuntime
+{
+ [AttributeUsageAttribute(AttributeTargets.Parameter, Inherited = false, AllowMultiple = false)]
+ public sealed class WriteOnlyArrayAttribute : Attribute
+ {
+ }
+}
+#endif
});
mres.Set ();
- Assert.IsTrue (mres2.WaitOne (2000), "#2");;
+ // this will only terminate correctly if the test was not executed from the main thread
+ // e.g. Touch.Unit defaults to run tests on the main thread and this will return false
+ Assert.AreEqual (Thread.CurrentThread.IsBackground, mres2.WaitOne (2000), "#2");;
}
}
}
}
[Test]
+ [Category("MobileNotWorking")]
public void Capture ()
{
ExecutionContext ec = ExecutionContext.Capture ();
}
[Test]
+ [Category("MobileNotWorking")]
public void Copy ()
{
ExecutionContext ec = ExecutionContext.Capture ();
}
[Test]
+ [Category("MobileNotWorking")]
public void IsFlowSuppressed ()
{
Assert.IsFalse (ExecutionContext.IsFlowSuppressed (), "IsFlowSuppressed-1");
[Test]
[ExpectedException (typeof (InvalidOperationException))]
+ [Category("MobileNotWorking")]
public void RestoreFlow_None ()
{
ExecutionContext.RestoreFlow ();
}
[Test]
+ [Category("MobileNotWorking")]
public void RestoreFlow_SuppressFlow ()
{
Assert.IsFalse (ExecutionContext.IsFlowSuppressed (), "IsFlowSuppressed-1");
[Test]
[ExpectedException (typeof (InvalidOperationException))]
+ [Category("MobileNotWorking")]
public void Run_SuppressFlow ()
{
Assert.IsFalse (ExecutionContext.IsFlowSuppressed ());
}
[Test]
+ [Category("MobileNotWorking")]
public void SuppressFlow ()
{
Assert.IsFalse (ExecutionContext.IsFlowSuppressed (), "IsFlowSuppressed-1");
[Test]
[ExpectedException (typeof (InvalidOperationException))]
+ [Category("MobileNotWorking")]
public void SuppressFlow_Two_Undo ()
{
Assert.IsFalse (ExecutionContext.IsFlowSuppressed (), "IsFlowSuppressed-1");
System.Runtime.InteropServices.ComTypes/VARFLAGS.cs
System.Runtime.InteropServices.ComTypes/VARKIND.cs
System.Runtime.InteropServices.Expando/IExpando.cs
+System.Runtime.InteropServices.WindowsRuntime/DefaultInterfaceAttribute.cs
+System.Runtime.InteropServices.WindowsRuntime/DesignerNamespaceResolveEventArgs.cs
+System.Runtime.InteropServices.WindowsRuntime/EventRegistrationToken.cs
+System.Runtime.InteropServices.WindowsRuntime/EventRegistrationTokenTable.cs
+System.Runtime.InteropServices.WindowsRuntime/IActivationFactory.cs
+System.Runtime.InteropServices.WindowsRuntime/InterfaceImplementedInVersionAttribute.cs
+System.Runtime.InteropServices.WindowsRuntime/NamespaceResolveEventArgs.cs
+System.Runtime.InteropServices.WindowsRuntime/ReadOnlyArrayAttribute.cs
+System.Runtime.InteropServices.WindowsRuntime/ReturnValueNameAttribute.cs
+System.Runtime.InteropServices.WindowsRuntime/WindowsRuntimeMarshal.cs
+System.Runtime.InteropServices.WindowsRuntime/WindowsRuntimeMetadata.cs
+System.Runtime.InteropServices.WindowsRuntime/WriteOnlyArrayAttribute.cs
System.Runtime.Remoting/ActivatedClientTypeEntry.cs
System.Runtime.Remoting/ActivatedServiceTypeEntry.cs
System.Runtime.Remoting/CustomErrorsModes.cs
d.PrepareEmit ();
site.AddTypeContainer (d);
+
+ //
+ // Add new container to inflated site container when the
+ // member cache already exists
+ //
+ if (site.CurrentType is InflatedTypeSpec && index > 0)
+ site.CurrentType.MemberCache.AddMember (d.CurrentType);
+
del_type = new TypeExpression (d.CurrentType, loc);
if (targs_for_instance != null) {
del_type_instance_access = null;
public LabeledStatement LookupLabel (string name)
{
- return ParametersBlock.TopBlock.GetLabel (name, this);
+ return ParametersBlock.GetLabel (name, this);
}
public override Reachability MarkReachable (Reachability rc)
protected bool resolved;
protected ToplevelBlock top_block;
protected StateMachine state_machine;
+ protected Dictionary<string, object> labels;
public ParametersBlock (Block parent, ParametersCompiled parameters, Location start, Flags flags = 0)
: base (parent, 0, start, start)
}
}
+ protected override void CloneTo (CloneContext clonectx, Statement t)
+ {
+ base.CloneTo (clonectx, t);
+
+ var target = (ParametersBlock) t;
+
+ //
+ // Clone label statements as well as they contain block reference
+ //
+ var pb = this;
+ while (true) {
+ if (pb.labels != null) {
+ target.labels = new Dictionary<string, object> ();
+
+ foreach (var entry in pb.labels) {
+ var list = entry.Value as List<LabeledStatement>;
+
+ if (list != null) {
+ var list_clone = new List<LabeledStatement> ();
+ foreach (var lentry in list) {
+ list_clone.Add (RemapLabeledStatement (lentry, lentry.Block, clonectx.RemapBlockCopy (lentry.Block)));
+ }
+
+ target.labels.Add (entry.Key, list_clone);
+ } else {
+ var labeled = (LabeledStatement) entry.Value;
+ target.labels.Add (entry.Key, RemapLabeledStatement (labeled, labeled.Block, clonectx.RemapBlockCopy (labeled.Block)));
+ }
+ }
+
+ break;
+ }
+
+ if (pb.Parent == null)
+ break;
+
+ pb = pb.Parent.ParametersBlock;
+ }
+ }
+
public override Expression CreateExpressionTree (ResolveContext ec)
{
if (statements.Count == 1) {
return res;
}
+ public LabeledStatement GetLabel (string name, Block block)
+ {
+ //
+ // Cloned parameters blocks can have their own cloned version of top-level labels
+ //
+ if (labels == null) {
+ if (Parent != null)
+ return Parent.ParametersBlock.GetLabel (name, block);
+
+ return null;
+ }
+
+ object value;
+ if (!labels.TryGetValue (name, out value)) {
+ return null;
+ }
+
+ var label = value as LabeledStatement;
+ Block b = block;
+ if (label != null) {
+ do {
+ if (label.Block == b)
+ return label;
+ b = b.Parent;
+ } while (b != null);
+ } else {
+ List<LabeledStatement> list = (List<LabeledStatement>) value;
+ for (int i = 0; i < list.Count; ++i) {
+ label = list[i];
+ if (label.Block == b)
+ return label;
+ }
+ }
+
+ return null;
+ }
+
public ParameterInfo GetParameterInfo (Parameter p)
{
for (int i = 0; i < parameters.Count; ++i) {
}
}
+ static LabeledStatement RemapLabeledStatement (LabeledStatement stmt, Block src, Block dst)
+ {
+ var src_stmts = src.Statements;
+ for (int i = 0; i < src_stmts.Count; ++i) {
+ if (src_stmts[i] == stmt)
+ return (LabeledStatement) dst.Statements[i];
+ }
+
+ throw new InternalErrorException ("Should never be reached");
+ }
+
public override bool Resolve (BlockContext bc)
{
// TODO: if ((flags & Flags.Resolved) != 0)
LocalVariable this_variable;
CompilerContext compiler;
Dictionary<string, object> names;
- Dictionary<string, object> labels;
List<ExplicitBlock> this_references;
return false;
}
- public LabeledStatement GetLabel (string name, Block block)
- {
- if (labels == null)
- return null;
-
- object value;
- if (!labels.TryGetValue (name, out value)) {
- return null;
- }
-
- var label = value as LabeledStatement;
- Block b = block;
- if (label != null) {
- do {
- if (label.Block == b.Original)
- return label;
- b = b.Parent;
- } while (b != null);
- } else {
- List<LabeledStatement> list = (List<LabeledStatement>) value;
- for (int i = 0; i < list.Count; ++i) {
- label = list[i];
- if (label.Block == b.Original)
- return label;
- }
- }
-
- return null;
- }
-
// <summary>
// This is used by non-static `struct' constructors which do not have an
// initializer - in this case, the constructor must initialize all of the
--- /dev/null
+using System;
+
+class X
+{
+ public static void Main ()
+ {
+ new C<int> ().Test ();
+ }
+}
+
+class C<T>
+{
+ public void Test ()
+ {
+ dynamic d = null;
+
+ int v;
+ int.TryParse (d, out v);
+
+ int.TryParse (d, out v);
+ }
+}
\ No newline at end of file
</method>\r
</type>\r
</test>\r
+ <test name="dtest-059.cs">\r
+ <type name="X">\r
+ <method name="Void Main()" attrs="150">\r
+ <size>12</size>\r
+ </method>\r
+ <method name="Void .ctor()" attrs="6278">\r
+ <size>7</size>\r
+ </method>\r
+ </type>\r
+ <type name="C`1[T]">\r
+ <method name="Void Test()" attrs="134">\r
+ <size>238</size>\r
+ </method>\r
+ <method name="Void .ctor()" attrs="6278">\r
+ <size>7</size>\r
+ </method>\r
+ </type>\r
+ <type name="C`1+<Test>c__DynamicSite0+Container0[T]">\r
+ <method name="Void Invoke(System.Runtime.CompilerServices.CallSite, System.Type, System.Object, Int32 ByRef)" attrs="454">\r
+ <size>0</size>\r
+ </method>\r
+ <method name="Void .ctor(Object, IntPtr)" attrs="6278">\r
+ <size>0</size>\r
+ </method>\r
+ </type>\r
+ <type name="C`1+<Test>c__DynamicSite0+Container1[T]">\r
+ <method name="Void Invoke(System.Runtime.CompilerServices.CallSite, System.Type, System.Object, Int32 ByRef)" attrs="454">\r
+ <size>0</size>\r
+ </method>\r
+ <method name="Void .ctor(Object, IntPtr)" attrs="6278">\r
+ <size>0</size>\r
+ </method>\r
+ </type>\r
+ </test>\r
<test name="dtest-anontype-01.cs">\r
<type name="C">\r
<method name="Void Main()" attrs="150">\r
#define amd64_sse_cvtsi2sd_reg_reg(inst,dreg,reg) amd64_sse_cvtsi2sd_reg_reg_size ((inst), (dreg), (reg), 8)
+#define amd64_sse_cvtsi2ss_reg_reg_size(inst,dreg,reg,size) emit_sse_reg_reg_size ((inst), (dreg), (reg), 0xf3, 0x0f, 0x2a, (size))
+
+#define amd64_sse_cvtsi2ss_reg_reg(inst,dreg,reg) amd64_sse_cvtsi2ss_reg_reg_size ((inst), (dreg), (reg), 8)
+
#define amd64_sse_cvtsd2ss_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf2, 0x0f, 0x5a)
#define amd64_sse_cvtss2sd_reg_reg(inst,dreg,reg) emit_sse_reg_reg ((inst), (dreg), (reg), 0xf3, 0x0f, 0x5a)
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
+/*
+ * SGen cannot deal with invalid pointers on the heap or in registered roots. Sometimes we
+ * need to copy or zero out memory in code that might be interrupted by collections. To
+ * guarantee that those operations will not result in invalid pointers, we must do it
+ * word-atomically.
+ *
+ * libc's bzero() and memcpy()/memmove() functions do not guarantee word-atomicity, even in
+ * cases where one would assume so. For instance, some implementations (like Darwin's on
+ * x86) have variants of memcpy() using vector instructions. Those may copy bytewise for
+ * the region preceding the first vector-aligned address. That region could be
+ * word-aligned, but it would still be copied byte-wise.
+ *
+ * All our memory writes here are to "volatile" locations. This is so that C compilers
+ * don't "optimize" our code back to calls to bzero()/memmove(). LLVM, specifically, will
+ * do that.
+ */
+
#include <config.h>
#include "metadata/gc-internal.h"
#endif
#define BZERO_WORDS(dest,words) do { \
- void **__d = (void**)(dest); \
+ void * volatile *__d = (void* volatile*)(dest); \
int __n = (words); \
int __i; \
for (__i = 0; __i < __n; ++__i) \
void
mono_gc_bzero (void *dest, size_t size)
{
- char *d = (char*)dest;
+ volatile char *d = (char*)dest;
size_t tail_bytes, word_bytes;
/*
}
#define MEMMOVE_WORDS_UPWARD(dest,src,words) do { \
- void **__d = (void**)(dest); \
+ void * volatile *__d = (void* volatile*)(dest); \
void **__s = (void**)(src); \
int __n = (int)(words); \
int __i; \
} while (0)
#define MEMMOVE_WORDS_DOWNWARD(dest,src,words) do { \
- void **__d = (void**)(dest); \
+ void * volatile *__d = (void* volatile*)(dest); \
void **__s = (void**)(src); \
int __n = (int)(words); \
int __i; \
* using memmove, which must handle it.
*/
if (dest > src && ((size_t)((char*)dest - (char*)src) < size)) { /*backward copy*/
- char *p = (char*)dest + size;
+ volatile char *p = (char*)dest + size;
char *s = (char*)src + size;
char *start = (char*)dest;
char *align_end = MAX((char*)dest, (char*)align_down (p));
while (p > start)
*--p = *--s;
} else {
- char *d = (char*)dest;
+ volatile char *d = (char*)dest;
const char *s = (const char*)src;
size_t tail_bytes;
#define SGEN_VTABLE_HAS_REFERENCES(vt) (sgen_gc_descr_has_references ((mword)((MonoVTable*)(vt))->gc_descr))
#define SGEN_CLASS_HAS_REFERENCES(c) (sgen_gc_descr_has_references ((mword)(c)->gc_descr))
+#define SGEN_OBJECT_HAS_REFERENCES(o) (SGEN_VTABLE_HAS_REFERENCES (SGEN_LOAD_VTABLE ((o))))
/* helper macros to scan and traverse objects, macros because we resue them in many functions */
#define OBJ_RUN_LEN_SIZE(size,desc,obj) do { \
continue;
}
sgen_los_pin_object (bigobj->data);
- /* FIXME: only enqueue if object has references */
- GRAY_OBJECT_ENQUEUE (WORKERS_DISTRIBUTE_GRAY_QUEUE, bigobj->data);
+ if (SGEN_OBJECT_HAS_REFERENCES (bigobj->data))
+ GRAY_OBJECT_ENQUEUE (WORKERS_DISTRIBUTE_GRAY_QUEUE, bigobj->data);
if (G_UNLIKELY (do_pin_stats))
sgen_pin_stats_register_object ((char*) bigobj->data, safe_object_get_size ((MonoObject*) bigobj->data));
SGEN_LOG (6, "Marked large object %p (%s) size: %lu from roots", bigobj->data, safe_name (bigobj->data), (unsigned long)sgen_los_object_size (bigobj));
info->pinned = pinned;
info->has_references = has_references;
info->has_pinned = pinned;
- info->is_to_space = (sgen_get_current_collection_generation () == GENERATION_OLD); /*FIXME WHY??? */
+ /*
+ * Blocks that are to-space are not evacuated from. During an major collection
+ * blocks are allocated for two reasons: evacuating objects from the nursery and
+ * evacuating them from major blocks marked for evacuation. In both cases we don't
+ * want further evacuation.
+ */
+ info->is_to_space = (sgen_get_current_collection_generation () == GENERATION_OLD);
info->swept = 1;
#ifndef FIXED_HEAP
info->block = ms_get_empty_block ();
#endif
sgen_los_pin_object (obj);
- /* FIXME: only enqueue if object has references */
- GRAY_OBJECT_ENQUEUE (queue, obj);
+ if (SGEN_OBJECT_HAS_REFERENCES (obj))
+ GRAY_OBJECT_ENQUEUE (queue, obj);
INC_NUM_MAJOR_OBJECTS_MARKED ();
}
}
#endif
sgen_los_pin_object (obj);
- /* FIXME: only enqueue if object has references */
- GRAY_OBJECT_ENQUEUE (queue, obj);
+ if (SGEN_OBJECT_HAS_REFERENCES (obj))
+ GRAY_OBJECT_ENQUEUE (queue, obj);
}
}
}
sweep_block (MSBlockInfo *block, gboolean during_major_collection)
{
int count;
+ void *reversed = NULL;
if (!during_major_collection)
g_assert (!sgen_concurrent_collection_in_progress ());
/* reset mark bits */
memset (block->mark_words, 0, sizeof (mword) * MS_NUM_MARK_WORDS);
- /*
- * FIXME: reverse free list so that it's in address
- * order
- */
+ /* Reverse free list so that it's in address order */
+ reversed = NULL;
+ while (block->free_list) {
+ void *next = *(void**)block->free_list;
+ *(void**)block->free_list = reversed;
+ reversed = block->free_list;
+ block->free_list = next;
+ }
+ block->free_list = reversed;
block->swept = 1;
}
case MONO_PATCH_INFO_METHOD_JUMP:
case MONO_PATCH_INFO_ICALL_ADDR:
case MONO_PATCH_INFO_METHOD_RGCTX:
+ case MONO_PATCH_INFO_METHOD_CODE_SLOT:
encode_method_ref (acfg, patch_info->data.method, p, &p);
break;
case MONO_PATCH_INFO_INTERNAL_METHOD:
{
switch (patch_info->type) {
case MONO_PATCH_INFO_METHOD:
- case MONO_PATCH_INFO_METHODCONST: {
+ case MONO_PATCH_INFO_METHODCONST:
+ case MONO_PATCH_INFO_METHOD_CODE_SLOT: {
MonoMethod *method = patch_info->data.method;
return can_encode_method (acfg, method);
case MONO_PATCH_INFO_METHOD:
case MONO_PATCH_INFO_METHOD_JUMP:
case MONO_PATCH_INFO_ICALL_ADDR:
- case MONO_PATCH_INFO_METHOD_RGCTX: {
+ case MONO_PATCH_INFO_METHOD_RGCTX:
+ case MONO_PATCH_INFO_METHOD_CODE_SLOT: {
MethodRef ref;
gboolean res;
return f == PositiveInfinity ? 0 : 1;
}
- /*
- Disabled until they can be fixed to run on amd64
-
static double VALUE = 0.19975845134874831D;
public static int test_0_float_conversion_reduces_double_precision () {
return 1;
return 0;
}
- */
+
+ public static int test_0_int8_to_float_convertion ()
+ {
+ double d = (double)(float)(long)INT_VAL;
+
+ if (d != 323315616)
+ return 1;
+ return 0;
+ }
}
long_conv_to_i2: dest:i src1:i len:4
long_conv_to_i4: dest:i src1:i len:3
long_conv_to_i8: dest:i src1:i len:3
-long_conv_to_r4: dest:f src1:i len:9
+long_conv_to_r4: dest:f src1:i len:15
long_conv_to_r8: dest:f src1:i len:9
long_conv_to_u4: dest:i src1:i len:3
long_conv_to_u8: dest:i src1:i len:3
int_neg: dest:i src1:i clob:1 len:4
int_not: dest:i src1:i clob:1 len:4
-int_conv_to_r4: dest:f src1:i len:9
+int_conv_to_r4: dest:f src1:i len:15
int_conv_to_r8: dest:f src1:i len:9
int_ceq: dest:c len:8
int_cgt: dest:c len:8
amd64_xor_membase_reg: src1:b src2:i len:13
amd64_mul_membase_reg: src1:b src2:i len:15
-float_conv_to_r4: dest:f src1:f
+float_conv_to_r4: dest:f src1:f len:17
vcall2: len:64 clob:c
vcall2_reg: src1:i len:64 clob:c
static MonoW32ExceptionHandler segv_handler;
LPTOP_LEVEL_EXCEPTION_FILTER mono_old_win_toplevel_exception_filter;
-guint64 mono_win_vectored_exception_handle;
+void *mono_win_vectored_exception_handle;
extern gboolean mono_win_chained_exception_needs_run;
#define W32_SEH_HANDLE_EX(_ex) \
if (_ex##_handler) _ex##_handler(0, ep, sctx)
-LONG CALLBACK seh_unhandled_exception_filter(EXCEPTION_POINTERS* ep)
+static LONG CALLBACK seh_unhandled_exception_filter(EXCEPTION_POINTERS* ep)
{
#ifndef MONO_CROSS_COMPILE
if (mono_old_win_toplevel_exception_filter) {
* Unhandled Exception Filter
* Top-level per-process exception handler.
*/
-LONG CALLBACK seh_vectored_exception_handler(EXCEPTION_POINTERS* ep)
+static LONG CALLBACK seh_vectored_exception_handler(EXCEPTION_POINTERS* ep)
{
EXCEPTION_RECORD* er;
CONTEXT* ctx;
void win32_seh_cleanup()
{
- if (mono_old_win_toplevel_exception_filter) SetUnhandledExceptionFilter(mono_old_win_toplevel_exception_filter);
-
guint32 ret = 0;
+ if (mono_old_win_toplevel_exception_filter) SetUnhandledExceptionFilter(mono_old_win_toplevel_exception_filter);
+
ret = RemoveVectoredExceptionHandler (mono_win_vectored_exception_handle);
g_assert (ret);
}
(sizeof (UNWIND_CODE) * (MONO_MAX_UNWIND_CODES - unwindinfo->unwindInfo.CountOfCodes));
}
-PRUNTIME_FUNCTION
+static PRUNTIME_FUNCTION
MONO_GET_RUNTIME_FUNCTION_CALLBACK ( DWORD64 ControlPc, IN PVOID Context )
{
MonoJitInfo *ji;
MonoMethodVar *vars = cfg->vars;
guint32 abs_pos = (bb->dfn << 16);
- for (inst_num = 0, ins = bb->code; ins; ins = ins->next, inst_num += 2) {
+ /* Start inst_num from > 0, so last_use.abs_pos is only 0 for dead variables */
+ for (inst_num = 2, ins = bb->code; ins; ins = ins->next, inst_num += 2) {
const char *spec = INS_INFO (ins->opcode);
int num_sregs, i;
int sregs [MONO_MAX_SRC_REGS];
if (type->byref)
return OP_MOVE;
+ type = mini_replace_type (type);
handle_enum:
switch (type->type) {
case MONO_TYPE_I1:
{
MonoClass *klass;
+ type = mini_replace_type (type);
inst->klass = klass = mono_class_from_mono_type (type);
if (type->byref) {
inst->type = STACK_MP;
if (!cfg->lmf_ir)
return;
- if (cfg->lmf_ir_mono_lmf) {
+ if (cfg->lmf_ir_mono_lmf && mini_tls_get_supported (cfg, TLS_KEY_LMF)) {
/* Load current lmf */
lmf_ins = mono_get_lmf_intrinsic (cfg);
g_assert (lmf_ins);
EMIT_NEW_VARLOADA (cfg, ins, cfg->lmf_var, NULL);
lmf_reg = ins->dreg;
- if (cfg->lmf_ir_mono_lmf) {
+ if (cfg->lmf_ir_mono_lmf && mini_tls_get_supported (cfg, TLS_KEY_LMF)) {
/* Load previous_lmf */
prev_lmf_reg = alloc_preg (cfg);
EMIT_NEW_LOAD_MEMBASE (cfg, ins, OP_LOAD_MEMBASE, prev_lmf_reg, lmf_reg, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
MonoType *simple_type;
MonoClass *klass;
+ target = mini_replace_type (target);
if (target->byref) {
/* FIXME: check that the pointed to types match */
if (arg->type == STACK_MP)
call->args = args;
call->signature = sig;
call->rgctx_reg = rgctx;
- sig_ret = sig->ret;
+ sig_ret = mini_replace_type (sig->ret);
type_to_eval_stack_type ((cfg), sig_ret, &call->inst);
* in mono_delegate_trampoline (), we allocate a per-domain memory slot to
* store it, and we fill it after the method has been compiled.
*/
- if (!cfg->compile_aot && !method->dynamic && !(cfg->opt & MONO_OPT_SHARED)) {
+ if (!method->dynamic && !(cfg->opt & MONO_OPT_SHARED)) {
MonoInst *code_slot_ins;
if (context_used) {
}
mono_domain_unlock (domain);
- EMIT_NEW_PCONST (cfg, code_slot_ins, code_slot);
+ if (cfg->compile_aot)
+ EMIT_NEW_AOTCONST (cfg, code_slot_ins, MONO_PATCH_INFO_METHOD_CODE_SLOT, method);
+ else
+ EMIT_NEW_PCONST (cfg, code_slot_ins, code_slot);
}
MONO_EMIT_NEW_STORE_MEMBASE (cfg, OP_STORE_MEMBASE_REG, obj->dreg, G_STRUCT_OFFSET (MonoDelegate, method_code), code_slot_ins->dreg);
}
{
static double r8_0 = 0.0;
MonoInst *ins;
+ int t;
- int t = rtype->type;
+ rtype = mini_replace_type (rtype);
+ t = rtype->type;
- if (t == MONO_TYPE_VALUETYPE && rtype->data.klass->enumtype)
- t = mono_class_enum_basetype (rtype->data.klass)->type;
if (rtype->byref) {
MONO_EMIT_NEW_PCONST (cfg, dreg, NULL);
} else if (t >= MONO_TYPE_BOOLEAN && t <= MONO_TYPE_U4) {
token = read32 (ip + 2);
klass = mini_get_class (cfg->current_method, token, cfg->generic_context);
CHECK_TYPELOAD (klass);
- type = &klass->byval_arg;
+ type = mini_replace_type (&klass->byval_arg);
emit_init_local (cfg, local, type);
return ip + 6;
}
/*
* Making generic calls out of gsharedvt methods.
*/
- if (cmethod && cfg->gsharedvt && mini_is_gsharedvt_variable_signature (fsig)) {
+ if (cmethod && cfg->gsharedvt && mini_is_gsharedvt_signature (cfg, fsig)) {
MonoRgctxInfoType info_type;
if (virtual) {
emit_pop_lmf (cfg);
if (cfg->ret) {
- MonoType *ret_type = mono_method_signature (method)->ret;
+ MonoType *ret_type = mini_replace_type (mono_method_signature (method)->ret);
if (seq_points && !sym_seq_points) {
/*
} ArgumentClass;
static ArgumentClass
-merge_argument_class_from_type (MonoType *type, ArgumentClass class1)
+merge_argument_class_from_type (MonoGenericSharingContext *gsctx, MonoType *type, ArgumentClass class1)
{
ArgumentClass class2 = ARG_CLASS_NO_CLASS;
MonoType *ptype;
- ptype = mini_type_get_underlying_type (NULL, type);
+ ptype = mini_type_get_underlying_type (gsctx, type);
switch (ptype->type) {
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_CHAR:
for (i = 0; i < info->num_fields; ++i) {
class2 = class1;
- class2 = merge_argument_class_from_type (info->fields [i].field->type, class2);
+ class2 = merge_argument_class_from_type (gsctx, info->fields [i].field->type, class2);
}
break;
}
/* (8 is size of quad) */
quadsize [quad] = info->fields [i].offset + size - (quad * 8);
- class1 = merge_argument_class_from_type (info->fields [i].field->type, class1);
+ class1 = merge_argument_class_from_type (gsctx, info->fields [i].field->type, class1);
}
g_assert (class1 != ARG_CLASS_NO_CLASS);
args [quad] = class1;
c1 = get_call_info (NULL, NULL, caller_sig);
c2 = get_call_info (NULL, NULL, callee_sig);
res = c1->stack_usage >= c2->stack_usage;
- callee_ret = callee_sig->ret;
+ callee_ret = mini_replace_type (callee_sig->ret);
if (callee_ret && MONO_TYPE_ISSTRUCT (callee_ret) && c2->ret.storage != ArgValuetypeInReg)
/* An address on the callee's stack is passed as the first argument */
res = FALSE;
sig = mono_method_signature (cfg->method);
cinfo = cfg->arch.cinfo;
- sig_ret = sig->ret;
+ sig_ret = mini_replace_type (sig->ret);
+
/*
* Contrary to mono_arch_allocate_vars (), the information should describe
* where the arguments are at the beginning of the method, not where they can be
sig = mono_method_signature (cfg->method);
cinfo = cfg->arch.cinfo;
- sig_ret = sig->ret;
+ sig_ret = mini_replace_type (sig->ret);
mono_arch_compute_omit_fp (cfg);
{
MonoMethodSignature *sig;
CallInfo *cinfo;
+ MonoType *sig_ret;
sig = mono_method_signature (cfg->method);
if (cinfo->ret.storage == ArgValuetypeInReg)
cfg->ret_var_is_local = TRUE;
- if ((cinfo->ret.storage != ArgValuetypeInReg) && MONO_TYPE_ISSTRUCT (sig->ret)) {
+ sig_ret = mini_replace_type (sig->ret);
+ if ((cinfo->ret.storage != ArgValuetypeInReg) && MONO_TYPE_ISSTRUCT (sig_ret)) {
cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG);
if (G_UNLIKELY (cfg->verbose_level > 1)) {
printf ("vret_addr = ");
MonoType *t, *sig_ret;
n = sig->param_count + sig->hasthis;
- sig_ret = sig->ret;
+ sig_ret = mini_replace_type (sig->ret);
+
cinfo = get_call_info (cfg->generic_sharing_context, cfg->mempool, sig);
linfo = mono_mempool_alloc0 (cfg->mempool, sizeof (LLVMCallInfo) + (sizeof (LLVMArgInfo) * n));
if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG) && (n == sig->sentinelpos))
emit_sig_cookie (cfg, call, cinfo);
+ sig_ret = mini_replace_type (sig->ret);
if (sig_ret && MONO_TYPE_ISSTRUCT (sig_ret)) {
MonoInst *vtarg;
void
mono_arch_emit_setret (MonoCompile *cfg, MonoMethod *method, MonoInst *val)
{
- MonoType *ret = mini_type_get_underlying_type (NULL, mono_method_signature (method)->ret);
+ MonoType *ret = mini_replace_type (mono_method_signature (method)->ret);
if (ret->type == MONO_TYPE_R4) {
if (COMPILE_LLVM (cfg))
amd64_sse_movss_reg_membase (code, ins->dreg, ins->inst_basereg, ins->inst_offset);
amd64_sse_cvtss2sd_reg_reg (code, ins->dreg, ins->dreg);
break;
- case OP_ICONV_TO_R4: /* FIXME: change precision */
+ case OP_ICONV_TO_R4:
+ amd64_sse_cvtsi2ss_reg_reg_size (code, ins->dreg, ins->sreg1, 4);
+ amd64_sse_cvtss2sd_reg_reg (code, ins->dreg, ins->dreg);
+ break;
case OP_ICONV_TO_R8:
amd64_sse_cvtsi2sd_reg_reg_size (code, ins->dreg, ins->sreg1, 4);
break;
- case OP_LCONV_TO_R4: /* FIXME: change precision */
+ case OP_LCONV_TO_R4:
+ amd64_sse_cvtsi2ss_reg_reg (code, ins->dreg, ins->sreg1);
+ amd64_sse_cvtss2sd_reg_reg (code, ins->dreg, ins->dreg);
+ break;
case OP_LCONV_TO_R8:
amd64_sse_cvtsi2sd_reg_reg (code, ins->dreg, ins->sreg1);
break;
case OP_FCONV_TO_R4:
- /* FIXME: nothing to do ?? */
+ amd64_sse_cvtsd2ss_reg_reg (code, ins->dreg, ins->sreg1);
+ amd64_sse_cvtss2sd_reg_reg (code, ins->dreg, ins->dreg);
break;
case OP_FCONV_TO_I1:
code = emit_float_to_int (cfg, code, ins->dreg, ins->sreg1, 1, TRUE);
guchar *code = p;
int save_mode = SAVE_NONE;
MonoMethod *method = cfg->method;
- MonoType *ret_type = mini_type_get_underlying_type (NULL, mono_method_signature (method)->ret);
+ MonoType *ret_type = mini_replace_type (mono_method_signature (method)->ret);
int i;
switch (ret_type->type) {
return NULL;
/* FIXME: Support more cases */
- if (MONO_TYPE_ISSTRUCT (sig->ret))
+ if (MONO_TYPE_ISSTRUCT (mini_replace_type (sig->ret)))
return NULL;
if (has_target) {
guint64 eip;
};
-typedef void (* MonoW32ExceptionHandler) (int _dummy, EXCEPTION_RECORD *info, void *context);
+typedef void (* MonoW32ExceptionHandler) (int _dummy, EXCEPTION_POINTERS *info, void *context);
void win32_seh_init(void);
void win32_seh_cleanup(void);
void win32_seh_set_handler(int type, MonoW32ExceptionHandler handler);
/* Special case structs with only a float member */
if (info->num_fields == 1) {
- int ftype = info->fields [0].field->type->type;
+ int ftype = mini_replace_type (info->fields [0].field->type)->type;
if ((info->native_size == 8) && (ftype == MONO_TYPE_R8)) {
ainfo->storage = ArgValuetypeInReg;
ainfo->pair_storage [0] = ArgOnDoubleFpStack;
* the extra stack space would be left on the stack after the tail call.
*/
res = c1->stack_usage >= c2->stack_usage;
- callee_ret = callee_sig->ret;
+ callee_ret = mini_replace_type (callee_sig->ret);
if (callee_ret && MONO_TYPE_ISSTRUCT (callee_ret) && c2->ret.storage != ArgValuetypeInReg)
/* An address on the callee's stack is passed as the first argument */
res = FALSE;
sig = mono_method_signature (cfg->method);
cinfo = get_call_info (cfg->generic_sharing_context, cfg->mempool, sig);
- sig_ret = sig->ret;
+ sig_ret = mini_replace_type (sig->ret);
if (cinfo->ret.storage == ArgValuetypeInReg)
cfg->ret_var_is_local = TRUE;
MonoType *t;
for (; start_arg < sig->param_count; ++start_arg) {
- t = mini_type_get_underlying_type (NULL, sig->params [start_arg]);
+ t = mini_replace_type (sig->params [start_arg]);
if (!t->byref && t->type == MONO_TYPE_R8) {
fp_space += sizeof (double);
*fp_arg_setup = start_arg;
sig = call->signature;
n = sig->param_count + sig->hasthis;
- sig_ret = sig->ret;
+ sig_ret = mini_replace_type (sig->ret);
cinfo = get_call_info (cfg->generic_sharing_context, cfg->mempool, sig);
if (type->byref)
return OP_STORE_MEMBASE_REG;
+ type = mini_replace_type (type);
+
handle_enum:
switch (type->type) {
case MONO_TYPE_I1:
if (type->byref)
return OP_LOAD_MEMBASE;
- type = mono_type_get_underlying_type (type);
+ type = mini_replace_type (type);
switch (type->type) {
case MONO_TYPE_I1:
guint
mini_type_to_stind (MonoCompile* cfg, MonoType *type)
{
+ type = mini_replace_type (type);
+
if (cfg->generic_sharing_context && !type->byref) {
if (type->type == MONO_TYPE_VAR || type->type == MONO_TYPE_MVAR) {
if (mini_type_var_is_vt (cfg, type))
int num = cfg->num_varinfo;
gboolean regpair;
+ type = mini_replace_type (type);
+
if ((num + 1) >= cfg->varinfo_count) {
int orig_count = cfg->varinfo_count;
cfg->varinfo_count = cfg->varinfo_count ? (cfg->varinfo_count * 2) : 64;
if (type->byref) {
mono_mark_vreg_as_mp (cfg, vreg);
} else {
- MonoType *t = mini_type_get_underlying_type (NULL, type);
+ MonoType *t = mini_replace_type (type);
if ((MONO_TYPE_ISSTRUCT (t) && inst->klass->has_references) || mini_type_is_reference (cfg, t)) {
inst->flags |= MONO_INST_GC_TRACK;
mono_mark_vreg_as_ref (cfg, vreg);
mono_compile_create_var (MonoCompile *cfg, MonoType *type, int opcode)
{
int dreg;
+ type = mini_replace_type (type);
if (mono_type_is_long (type))
dreg = mono_alloc_dreg (cfg, STACK_I8);
return ins;
}
+gboolean
+mini_tls_get_supported (MonoCompile *cfg, MonoTlsKey key)
+{
+ if (!MONO_ARCH_HAVE_TLS_GET)
+ return FALSE;
+
+ if (cfg->compile_aot)
+ return ARCH_HAVE_TLS_GET_REG;
+ else
+ return mini_get_tls_offset (key) != -1;
+}
+
MonoInst*
mono_create_tls_get (MonoCompile *cfg, MonoTlsKey key)
{
case MONO_PATCH_INFO_DELEGATE_TRAMPOLINE:
case MONO_PATCH_INFO_SIGNATURE:
case MONO_PATCH_INFO_TLS_OFFSET:
+ case MONO_PATCH_INFO_METHOD_CODE_SLOT:
return (ji->type << 8) | (gssize)ji->data.target;
case MONO_PATCH_INFO_GSHAREDVT_CALL:
return (ji->type << 8) | (gssize)ji->data.gsharedvt->method;
}
#endif
break;
+ case MONO_PATCH_INFO_METHOD_CODE_SLOT: {
+ gpointer code_slot;
+
+ mono_domain_lock (domain);
+ if (!domain_jit_info (domain)->method_code_hash)
+ domain_jit_info (domain)->method_code_hash = g_hash_table_new (NULL, NULL);
+ code_slot = g_hash_table_lookup (domain_jit_info (domain)->method_code_hash, patch_info->data.method);
+ if (!code_slot) {
+ code_slot = mono_domain_alloc0 (domain, sizeof (gpointer));
+ g_hash_table_insert (domain_jit_info (domain)->method_code_hash, patch_info->data.method, code_slot);
+ }
+ mono_domain_unlock (domain);
+ target = code_slot;
+ break;
+ }
case MONO_PATCH_INFO_SWITCH: {
gpointer *jump_table;
int i;
if (supported)
info->dyn_call_info = mono_arch_dyn_call_prepare (sig);
- ret_type = sig->ret;
+ ret_type = mini_replace_type (sig->ret);
if (info->dyn_call_info) {
switch (ret_type->type) {
case MONO_TYPE_VOID:
if (sig->hasthis)
args [pindex ++] = &obj;
for (i = 0; i < sig->param_count; ++i) {
- MonoType *t = sig->params [i];
+ MonoType *t = mini_replace_type (sig->params [i]);
if (t->byref) {
args [pindex ++] = ¶ms [i];
return mono_arch_jumptable_entry_from_code (code_ptr);
}
#endif
+
+/*
+ * mini_replace_type:
+ *
+ * Replace the type used in the metadata stream with what the JIT will actually use during compilation.
+*/
+MonoType*
+mini_replace_type (MonoType *type)
+{
+ return mono_type_get_underlying_type (type);
+}
gint32 mono_get_lmf_tls_offset (void) MONO_INTERNAL;
gint32 mono_get_lmf_addr_tls_offset (void) MONO_INTERNAL;
int mini_get_tls_offset (MonoTlsKey key) MONO_INTERNAL;
+gboolean mini_tls_get_supported (MonoCompile *cfg, MonoTlsKey key) MONO_INTERNAL;
MonoInst* mono_create_tls_get (MonoCompile *cfg, MonoTlsKey key) MONO_INTERNAL;
MonoInst* mono_get_jit_tls_intrinsic (MonoCompile *cfg) MONO_INTERNAL;
MonoInst* mono_get_domain_intrinsic (MonoCompile* cfg) MONO_INTERNAL;
MonoClass* mini_class_get_container_class (MonoClass *class) MONO_INTERNAL;
MonoGenericContext* mini_class_get_context (MonoClass *class) MONO_INTERNAL;
+MonoType* mini_replace_type (MonoType *type) MONO_INTERNAL;
MonoType* mini_get_basic_type_from_generic (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
MonoType* mini_type_get_underlying_type (MonoGenericSharingContext *gsctx, MonoType *type) MONO_INTERNAL;
MonoMethod* mini_get_shared_method (MonoMethod *method) MONO_INTERNAL;
PATCH_INFO(JIT_TLS_ID, "jit_tls_id")
PATCH_INFO(TLS_OFFSET, "tls_offset")
PATCH_INFO(OBJC_SELECTOR_REF, "objc_selector_ref")
+PATCH_INFO(METHOD_CODE_SLOT, "method_code_slot")
PATCH_INFO(NONE, "none")
-
-
-
using System.Threading;
public class FinalizerException {
+
~FinalizerException () {
throw new Exception ();
}
+ static IntPtr aptr;
+
/*
* We allocate the exception object deep down the stack so
* that it doesn't get pinned.
public static unsafe void MakeException (int depth) {
// Avoid tail calls
int* values = stackalloc int [20];
+ aptr = new IntPtr (values);
if (depth <= 0) {
new FinalizerException ();
return;
* Copyright 2013 Xamarin, Inc (http://www.xamarin.com)
*/
+#include <config.h>
+
#include "mono-tls.h"
static int tls_offsets [TLS_KEY_NUM];
winsetup.bat
update-def:
- perl create-windef.pl mono.def
+ perl create-windef.pl mono.def ../mono/mini/.libs/libmonoboehm-2.0.so mono-2.0.dll
+ perl create-windef.pl monosgen.def ../mono/mini/.libs/libmonosgen-2.0.so monosgen-2.0.dll
use strict;
my $outfile = shift || usage ();
+my $soname = shift || usage ();
+my $dllname = shift || usage ();
my @symbols = ();
my %excludes = ();
-my $cmd = "nm -D ../mono/mini/.libs/libmono-2.0.so";
+my $cmd = "nm -D $soname";
@excludes {qw(
mono_class_setup_vtable_general_new mono_debugger_init mono_debugger_main
mono_once mono_pthread_key_for_tls
mono_gc_pthread_create mono_gc_pthread_detach mono_gc_pthread_join
+ mono_gc_pthread_exit
+ mono_file_map_fileio mono_file_unmap_fileio
+ mono_file_map_set_allocator
)} = ();
open (SYMS, "$cmd |") || die "Cannot run \$cmd': $!\n";
open (OUT, ">$outfile") || die "Cannot open '$outfile': $!\n";
print OUT "; file generated by create-windef.pl\n";
-print OUT "LIBRARY mono-2.0.dll\nEXPORTS\n";
+print OUT "LIBRARY $dllname\nEXPORTS\n";
print OUT join ("\n", @symbols);
print OUT "\n";
close (OUT);
sub usage {
- print "Usage: create-windef.pl output_file\n";
+ print "Usage: create-windef.pl output_file soname dllname\n";
exit (1);
}
</ItemGroup>\r
<Import Project="mono.props" />\r
<ItemGroup>\r
+ <ClCompile Include="..\mono\mini\alias-analysis.c" />\r
<ClCompile Include="..\mono\mini\exceptions-amd64.c">\r
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>\r
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug_SGen|Win32'">true</ExcludedFromBuild>\r
<ClCompile Include="..\mono\mini\local-propagation.c" />\r
<ClCompile Include="..\mono\mini\driver.c" />\r
<ClCompile Include="..\mono\mini\debug-mini.c" />\r
- <ClInclude Include="..\mono\mini\debug-mini.h" />\r
<ClCompile Include="..\mono\mini\linear-scan.c" />\r
<ClCompile Include="..\mono\mini\aot-compiler.c" />\r
<ClCompile Include="..\mono\mini\aot-runtime.c" />\r
<ClCompile Include="..\mono\mini\mini-gc.c" />\r
<ClInclude Include="..\mono\mini\debugger-agent.h " />\r
<ClCompile Include="..\mono\mini\debugger-agent.c" />\r
- <ClCompile Include="..\mono\mini\debug-debugger.c" />\r
- <ClInclude Include="..\mono\mini\debug-debugger.h" />\r
<ClCompile Include="..\mono\mini\xdebug.c" />\r
<ClInclude Include="..\mono\mini\mini-llvm.h" />\r
<ClInclude Include="..\mono\mini\mini-llvm-cpp.h" />\r
<ClCompile Include="..\mono\metadata\exception.c" />\r
<ClCompile Include="..\mono\metadata\file-io.c" />\r
<ClCompile Include="..\mono\metadata\filewatcher.c" />\r
+ <ClCompile Include="..\mono\metadata\gc-memfuncs.c" />\r
<ClCompile Include="..\mono\metadata\gc.c" />\r
<ClCompile Include="..\mono\metadata\icall.c" />\r
<ClCompile Include="..\mono\metadata\image.c" />\r
<ClCompile Include="..\mono\utils\mono-threads-windows.c" />\r
<ClCompile Include="..\mono\utils\mono-threads.c" />\r
<ClCompile Include="..\mono\utils\mono-time.c" />\r
+ <ClCompile Include="..\mono\utils\mono-tls.c" />\r
<ClCompile Include="..\mono\utils\mono-uri.c" />\r
<ClCompile Include="..\mono\utils\mono-value-hash.c" />\r
<ClCompile Include="..\mono\utils\monobitset.c" />\r
; file generated by create-windef.pl
LIBRARY mono-2.0.dll
EXPORTS
+MonoFixupCorEE
mono_add_internal_call
mono_aot_register_globals
mono_aot_register_module
mono_assembly_open_full
mono_assembly_set_main
mono_assembly_setrootdir
+mono_binary_search
mono_bitset_alloc_size
mono_bitset_clear
mono_bitset_clear_all
mono_class_from_typeref
mono_class_get
mono_class_get_byref_type
+mono_class_get_com_object_class
mono_class_get_element_class
mono_class_get_event_token
mono_class_get_events
mono_class_get_fields
mono_class_get_flags
mono_class_get_full
+mono_class_get_idispatch_class
mono_class_get_image
mono_class_get_interfaces
+mono_class_get_interop_proxy_class
+mono_class_get_iunknown_class
mono_class_get_method_from_name
mono_class_get_method_from_name_flags
mono_class_get_methods
mono_class_get_rank
mono_class_get_type
mono_class_get_type_token
+mono_class_get_variant_class
+mono_class_implements_interface
mono_class_inflate_generic_method
mono_class_inflate_generic_type
mono_class_init
mono_class_instance_size
mono_class_interface_offset
mono_class_is_assignable_from
+mono_class_is_delegate
mono_class_is_enum
mono_class_is_subclass_of
mono_class_is_valid_enum
mono_class_value_size
mono_class_vtable
mono_cli_rva_image_map
+mono_code_manager_cleanup
mono_code_manager_commit
mono_code_manager_destroy
mono_code_manager_foreach
+mono_code_manager_init
mono_code_manager_invalidate
mono_code_manager_new
mono_code_manager_new_dynamic
mono_compile_method
mono_config_cleanup
mono_config_for_assembly
+mono_config_is_server_mode
mono_config_parse
mono_config_parse_memory
+mono_config_set_server_mode
mono_config_string_for_assembly_file
mono_context_get
mono_context_get_desc
mono_debug_close_mono_symbol_file
mono_debug_domain_create
mono_debug_domain_unload
+mono_debug_enabled
mono_debug_find_method
mono_debug_free_method_jit_info
mono_debug_free_source_location
mono_debug_open_mono_symbols
mono_debug_print_stack_frame
mono_debug_print_vars
+mono_debug_remove_method
mono_debug_symfile_free_locals
mono_debug_symfile_free_location
mono_debug_symfile_get_line_numbers
+mono_debug_symfile_get_line_numbers_full
mono_debug_symfile_is_loaded
mono_debug_symfile_lookup_locals
mono_debug_symfile_lookup_location
mono_debug_symfile_lookup_method
-mono_debug_using_mono_debugger
-mono_debugger_breakpoint_callback
-mono_debugger_call_exception_handler
-mono_debugger_check_breakpoints
-mono_debugger_check_interruption
-mono_debugger_check_runtime_version
-mono_debugger_class_initialized
-mono_debugger_cleanup
-mono_debugger_event
-mono_debugger_event_create_appdomain
-mono_debugger_event_unload_appdomain
-mono_debugger_extended_notification
-mono_debugger_handle_exception
-mono_debugger_initialize
+mono_debugger_agent_register_transport
mono_debugger_insert_breakpoint
-mono_debugger_insert_breakpoint_full
-mono_debugger_insert_method_breakpoint
-mono_debugger_lock
mono_debugger_method_has_breakpoint
-mono_debugger_register_class_init_callback
-mono_debugger_remove_breakpoint
-mono_debugger_remove_class_init_callback
-mono_debugger_remove_method_breakpoint
mono_debugger_run_finally
-mono_debugger_thread_cleanup
-mono_debugger_thread_created
-mono_debugger_trampoline_compiled
-mono_debugger_unlock
mono_declsec_flags_from_assembly
mono_declsec_flags_from_class
mono_declsec_flags_from_method
mono_domain_try_type_resolve
mono_domain_try_unload
mono_domain_unload
+mono_dwarf_escape_path
mono_emit_native_call
mono_environment_exitcode_get
mono_environment_exitcode_set
mono_exception_from_name_two_strings
mono_exception_from_token
mono_exception_from_token_two_strings
+mono_exception_walk_trace
mono_field_from_token
mono_field_full_name
mono_field_get_data
mono_gc_get_used_size
mono_gc_invoke_finalizers
mono_gc_is_finalizer_thread
+mono_gc_make_root_descr_user
mono_gc_max_generation
mono_gc_out_of_memory
+mono_gc_reference_queue_add
+mono_gc_reference_queue_free
+mono_gc_reference_queue_new
mono_gc_walk_heap
mono_gc_wbarrier_arrayref_copy
mono_gc_wbarrier_generic_nostore
mono_get_config_dir
mono_get_corlib
mono_get_dbnull_object
+mono_get_delegate_begin_invoke
+mono_get_delegate_end_invoke
mono_get_delegate_invoke
mono_get_double_class
mono_get_enum_class
mono_get_method_full
mono_get_object_class
mono_get_root_domain
+mono_get_runtime_build_info
mono_get_sbyte_class
mono_get_single_class
mono_get_string_class
mono_install_runtime_cleanup
mono_install_threadpool_item_hooks
mono_install_threadpool_thread_hooks
+mono_install_unhandled_exception_hook
+mono_invoke_unhandled_exception_hook
mono_is_debugger_attached
mono_jit_cleanup
mono_jit_exec
mono_jit_init_version
mono_jit_parse_options
mono_jit_set_aot_only
+mono_jit_set_domain
mono_jit_set_trace_options
mono_jit_thread_attach
mono_ldstr
mono_ldtoken
+mono_lls_init
mono_load_remote_field
mono_load_remote_field_new
mono_local_deadce
mono_locks_dump
+mono_lookup_icall_symbol
mono_lookup_internal_call
mono_lookup_pinvoke_call
mono_main
mono_monitor_exit
mono_monitor_try_enter
mono_mprotect
+mono_mutex_init_suspend_safe
mono_object_castclass_mbyref
mono_object_castclass_with_cache
mono_object_clone
mono_reflection_get_type
mono_reflection_parse_type
mono_reflection_type_from_name
+mono_reflection_type_get_type
mono_register_bundled_assemblies
mono_register_config_for_assembly
mono_register_machine_config
mono_runtime_is_shutting_down
mono_runtime_object_init
mono_runtime_quit
+mono_runtime_resource_check_limit
+mono_runtime_resource_limit
+mono_runtime_resource_set_callback
mono_runtime_run_main
mono_runtime_set_shutting_down
+mono_security_core_clr_get_options
mono_security_core_clr_require_elevated_permissions
+mono_security_core_clr_set_options
mono_security_enable_core_clr
mono_security_set_core_clr_platform_callback
mono_sem_post
mono_signature_get_return_type
mono_signature_hash
mono_signature_is_instance
+mono_signature_param_is_out
mono_signature_vararg_start
mono_signbit_double
mono_signbit_float
mono_thread_get_main
mono_thread_get_undeniable_exception
mono_thread_init
+mono_thread_is_foreign
mono_thread_manage
mono_thread_new_init
mono_thread_set_main
mono_threads_get_default_stacksize
mono_threads_request_thread_dump
mono_threads_set_default_stacksize
+mono_tls_key_get_offset
+mono_tls_key_set_offset
mono_trace_set_level_string
mono_trace_set_mask_string
mono_type_create_from_typespec
mono_utf8_validate_and_len
mono_utf8_validate_and_len_with_bounds
mono_valloc
+mono_valloc_aligned
mono_value_box
mono_value_copy
mono_value_copy_array
; file generated by create-windef.pl
LIBRARY monosgen-2.0.dll
EXPORTS
+MonoFixupCorEE
mono_add_internal_call
mono_aot_register_globals
mono_aot_register_module
mono_assembly_open_full
mono_assembly_set_main
mono_assembly_setrootdir
+mono_binary_search
mono_bitset_alloc_size
mono_bitset_clear
mono_bitset_clear_all
mono_class_from_typeref
mono_class_get
mono_class_get_byref_type
+mono_class_get_com_object_class
mono_class_get_element_class
mono_class_get_event_token
mono_class_get_events
mono_class_get_fields
mono_class_get_flags
mono_class_get_full
+mono_class_get_idispatch_class
mono_class_get_image
mono_class_get_interfaces
+mono_class_get_interop_proxy_class
+mono_class_get_iunknown_class
mono_class_get_method_from_name
mono_class_get_method_from_name_flags
mono_class_get_methods
mono_class_get_rank
mono_class_get_type
mono_class_get_type_token
+mono_class_get_variant_class
+mono_class_implements_interface
mono_class_inflate_generic_method
mono_class_inflate_generic_type
mono_class_init
mono_class_instance_size
mono_class_interface_offset
mono_class_is_assignable_from
+mono_class_is_delegate
mono_class_is_enum
mono_class_is_subclass_of
mono_class_is_valid_enum
mono_class_value_size
mono_class_vtable
mono_cli_rva_image_map
+mono_code_manager_cleanup
mono_code_manager_commit
mono_code_manager_destroy
mono_code_manager_foreach
+mono_code_manager_init
mono_code_manager_invalidate
mono_code_manager_new
mono_code_manager_new_dynamic
mono_compile_method
mono_config_cleanup
mono_config_for_assembly
+mono_config_is_server_mode
mono_config_parse
mono_config_parse_memory
+mono_config_set_server_mode
mono_config_string_for_assembly_file
mono_context_get
mono_context_get_desc
mono_debug_close_mono_symbol_file
mono_debug_domain_create
mono_debug_domain_unload
+mono_debug_enabled
mono_debug_find_method
mono_debug_free_method_jit_info
mono_debug_free_source_location
mono_debug_open_mono_symbols
mono_debug_print_stack_frame
mono_debug_print_vars
+mono_debug_remove_method
mono_debug_symfile_free_locals
mono_debug_symfile_free_location
mono_debug_symfile_get_line_numbers
+mono_debug_symfile_get_line_numbers_full
mono_debug_symfile_is_loaded
mono_debug_symfile_lookup_locals
mono_debug_symfile_lookup_location
mono_debug_symfile_lookup_method
-mono_debug_using_mono_debugger
-mono_debugger_breakpoint_callback
-mono_debugger_call_exception_handler
-mono_debugger_check_breakpoints
-mono_debugger_check_interruption
-mono_debugger_check_runtime_version
-mono_debugger_class_initialized
-mono_debugger_cleanup
-mono_debugger_event
-mono_debugger_event_create_appdomain
-mono_debugger_event_unload_appdomain
-mono_debugger_extended_notification
-mono_debugger_handle_exception
-mono_debugger_initialize
+mono_debugger_agent_register_transport
mono_debugger_insert_breakpoint
-mono_debugger_insert_breakpoint_full
-mono_debugger_insert_method_breakpoint
-mono_debugger_lock
mono_debugger_method_has_breakpoint
-mono_debugger_register_class_init_callback
-mono_debugger_remove_breakpoint
-mono_debugger_remove_class_init_callback
-mono_debugger_remove_method_breakpoint
mono_debugger_run_finally
-mono_debugger_thread_cleanup
-mono_debugger_thread_created
-mono_debugger_trampoline_compiled
-mono_debugger_unlock
mono_declsec_flags_from_assembly
mono_declsec_flags_from_class
mono_declsec_flags_from_method
mono_domain_try_type_resolve
mono_domain_try_unload
mono_domain_unload
+mono_dwarf_escape_path
mono_emit_native_call
mono_environment_exitcode_get
mono_environment_exitcode_set
mono_exception_from_name_two_strings
mono_exception_from_token
mono_exception_from_token_two_strings
+mono_exception_walk_trace
mono_field_from_token
mono_field_full_name
mono_field_get_data
mono_gc_get_used_size
mono_gc_invoke_finalizers
mono_gc_is_finalizer_thread
+mono_gc_make_root_descr_user
mono_gc_max_generation
mono_gc_out_of_memory
+mono_gc_reference_queue_add
+mono_gc_reference_queue_free
+mono_gc_reference_queue_new
+mono_gc_register_bridge_callbacks
+mono_gc_scan_for_specific_ref
+mono_gc_toggleref_add
+mono_gc_toggleref_register_callback
+mono_gc_wait_for_bridge_processing
mono_gc_walk_heap
mono_gc_wbarrier_arrayref_copy
mono_gc_wbarrier_generic_nostore
mono_get_config_dir
mono_get_corlib
mono_get_dbnull_object
+mono_get_delegate_begin_invoke
+mono_get_delegate_end_invoke
mono_get_delegate_invoke
mono_get_double_class
mono_get_enum_class
mono_get_method_full
mono_get_object_class
mono_get_root_domain
+mono_get_runtime_build_info
mono_get_sbyte_class
mono_get_single_class
mono_get_string_class
mono_install_runtime_cleanup
mono_install_threadpool_item_hooks
mono_install_threadpool_thread_hooks
+mono_install_unhandled_exception_hook
+mono_invoke_unhandled_exception_hook
mono_is_debugger_attached
mono_jit_cleanup
mono_jit_exec
mono_jit_init_version
mono_jit_parse_options
mono_jit_set_aot_only
+mono_jit_set_domain
mono_jit_set_trace_options
mono_jit_thread_attach
mono_ldstr
mono_ldtoken
+mono_lls_init
mono_load_remote_field
mono_load_remote_field_new
mono_local_deadce
mono_locks_dump
+mono_lookup_icall_symbol
mono_lookup_internal_call
mono_lookup_pinvoke_call
mono_main
mono_monitor_exit
mono_monitor_try_enter
mono_mprotect
+mono_mutex_init_suspend_safe
mono_object_castclass_mbyref
mono_object_castclass_with_cache
mono_object_clone
mono_reflection_get_type
mono_reflection_parse_type
mono_reflection_type_from_name
+mono_reflection_type_get_type
mono_register_bundled_assemblies
mono_register_config_for_assembly
mono_register_machine_config
mono_runtime_is_shutting_down
mono_runtime_object_init
mono_runtime_quit
+mono_runtime_resource_check_limit
+mono_runtime_resource_limit
+mono_runtime_resource_set_callback
mono_runtime_run_main
mono_runtime_set_shutting_down
+mono_security_core_clr_get_options
mono_security_core_clr_require_elevated_permissions
+mono_security_core_clr_set_options
mono_security_enable_core_clr
mono_security_set_core_clr_platform_callback
mono_sem_post
mono_signature_get_return_type
mono_signature_hash
mono_signature_is_instance
+mono_signature_param_is_out
mono_signature_vararg_start
mono_signbit_double
mono_signbit_float
mono_thread_get_main
mono_thread_get_undeniable_exception
mono_thread_init
+mono_thread_is_foreign
mono_thread_manage
mono_thread_new_init
mono_thread_set_main
mono_threads_get_default_stacksize
mono_threads_request_thread_dump
mono_threads_set_default_stacksize
+mono_tls_key_get_offset
+mono_tls_key_set_offset
mono_trace_set_level_string
mono_trace_set_mask_string
mono_type_create_from_typespec
mono_utf8_validate_and_len
mono_utf8_validate_and_len_with_bounds
mono_valloc
+mono_valloc_aligned
mono_value_box
mono_value_copy
mono_value_copy_array
/* Define to 1 if you have the <curses.h> header file. */
/* #undef HAVE_CURSES_H */
+/* Define to 1 if you have the declaration of `InterlockedAdd',
+ and to 0 if you don't. */
+#define HAVE_DECL_INTERLOCKEDADD 1
+
+/* Define to 1 if you have the declaration of `InterlockedAdd64',
+ and to 0 if you don't. */
+#define HAVE_DECL_INTERLOCKEDADD64 1
+
/* Define to 1 if you have the declaration of `InterlockedCompareExchange64',
and to 0 if you don't. */
#define HAVE_DECL_INTERLOCKEDCOMPAREEXCHANGE64 1
+/* Define to 1 if you have the declaration of `InterlockedDecrement64',
+ and to 0 if you don't. */
+#define HAVE_DECL_INTERLOCKEDDECREMENT64 1
+
+/* Define to 1 if you have the declaration of `InterlockedExchange64',
+ and to 0 if you don't. */
+#define HAVE_DECL_INTERLOCKEDEXCHANGE64 1
+
+/* Define to 1 if you have the declaration of `InterlockedIncrement64',
+ and to 0 if you don't. */
+#define HAVE_DECL_INTERLOCKEDINCREMENT64 1
+
/* Define to 1 if you have the declaration of `__readfsdword',
and to 0 if you don't. */
#define HAVE_DECL___READFSDWORD 1
projects / mono.git / commitdiff